My Blog

host
My Blog
RssIcon

Marshal native struct array to managed struct array

by lupok on lunedì 28 luglio 2014 07:25
// MarshalArrayOfStructures.cpp : main project file.
 
#include "stdafx.h"
#include "MyNativeStruct.h"
#include "MyManagedStruct.h"
#include <stdlib.h>
#include <string.h>
 
using namespace System;
using namespace System::Runtime::InteropServices;
 
struct MyNativeStruct
{
public:
   int myInt;
   double myDouble;
   float myFloat;
}; 
 
[StructLayout(LayoutKind::Sequential)]
public value struct MyManagedStruct
{
public:
   int myInt;
   double myDouble;
   float myFloat;
};
 
array<MyManagedStruct>^ marshalNativeArrayOfMyStruct(const MyNativeStructvectorint size)
{
   array<MyManagedStruct>^ result = gcnew array<MyManagedStruct>(static_cast<int>(size));
 
   if (size) {
      pin_ptr<MyManagedStruct> dest = &result[0];
      memcpy(dest, &vector[0], size * sizeof(MyNativeStruct));
   }
 
   return result;
}
 
 
int main(array<System::String ^> ^args)
{
   MyNativeStruct myNativeStructArray[5] = 
   { 
      { 100, 34.5, 56.4f }, { 200, 66.7, 78.2f }, 
      { 300, 88.9, 8.566f }, { 400, 7438.3, 937589.487f }, 
      { 500, 0.64567, 84677.4887f } 
   };
 
   array<MyManagedStruct>^ myManagedStructArray = 
      gcnew array<MyManagedStruct>(_countof(myNativeStructArray));
 
   myManagedStructArray = marshalNativeArrayOfMyStruct(myNativeStructArray, 
      _countof(myNativeStructArray));
 
   Console::WriteLine(L"Hello World");
   return 0;
}
VC++/CLI

How to: Wrap Native Class for Use by C#

by lupok on giovedì 12 giugno 2014 15:39

Esempio tratto da MSDN How to: Wrap Native Class for Use by C#

 

// wrap_native_class_for_mgd_consumption.cpp
// compile with: /clr /LD
#include <windows.h>
#include <vcclr.h>
#using <System.dll>

using namespace System;

class UnmanagedClass {
public:
   LPCWSTR GetPropertyA() { return 0; }
   void MethodB( LPCWSTR ) {}
};

public ref class ManagedClass {
public:
   // Allocate the native object on the C++ Heap via a constructor
   ManagedClass() : m_Impl( new UnmanagedClass ) {}
   
   // Deallocate the native object on a destructor
   ~ManagedClass() {
      delete m_Impl;
   }

protected:
   // Deallocate the native object on the finalizer just in case no destructor is called
   !ManagedClass() {
      delete m_Impl;
   }

public:
   property String ^  get_PropertyA {
      String ^ get() {
         return gcnew String( m_Impl->GetPropertyA());
      }
   }

   void MethodB( String ^ theString ) {
      pin_ptr<const WCHAR> str = PtrToStringChars(theString);
      m_Impl->MethodB(str);
   }

private:
   UnmanagedClass * m_Impl;
};
VC++/CLI
Wrapper

ThreeJS QuoteHelper

by lupok on lunedì 9 giugno 2014 01:13
ThreeJS QuoteHelper is a utility for displaying the size of an 3d object in technical drawing style

 

 

ThreeJS

ThreeJS Collada loader

by lupok on lunedì 21 aprile 2014 08:14
ThreeJS
Collada

Magic enum converter

by lupok on giovedì 10 aprile 2014 09:12
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
 
namespace MyMagicEnumConverter
{
   #region MyMagicEnumConverter
   public class MyMagicEnumConverter<TENUM, TATTR> : 
      StringConverter where TATTR : MyNameBaseAttribute
   {
 
      public override bool GetStandardValuesSupported(
         ITypeDescriptorContext context)
      {
         return true;
      }
 
      public override bool GetStandardValuesExclusive(
         ITypeDescriptorContext context)
      {
         return true;
      }
 
      public override StandardValuesCollection GetStandardValues(
         ITypeDescriptorContext context)
      {
         List<String> values = new List<String>();
 
         foreach (var item in Enum.GetNames(typeof(TENUM)))
         {
            System.Reflection.MemberInfo[] mi = typeof(TENUM).GetMember(item);
 
            Object[] attributes = mi[0].GetCustomAttributes(typeof(TATTR), false);
 
            if (attributes.Length > 0)
               values.Add(((TATTR)attributes[0]).Name);
            else
               values.Add(item);
         }
 
         return new StandardValuesCollection(values);
      }
 
      public override bool CanConvertFrom(ITypeDescriptorContext context, 
         Type sourceType)
      {
         if (sourceType == typeof(String))
            return true;
 
         return base.CanConvertFrom(context, sourceType);
      }
 
      public override object ConvertFrom(ITypeDescriptorContext context, 
         System.Globalization.CultureInfo culture, object value)
      {
         if (value != null && value.GetType() == typeof(String))
         {
            foreach (var item in Enum.GetNames(typeof(TENUM)))
            {
               System.Reflection.MemberInfo[] mi = typeof(TENUM).GetMember(item);
 
               Object[] attributes = mi[0].GetCustomAttributes(typeof(TATTR), false);
 
               if (attributes.Length > 0)
               {
                  if (Convert.ToString(value) == ((TATTR)attributes[0]).Name)
                     return Enum.Parse(typeof(TENUM), item);
               }
            }
 
            return Enum.Parse(typeof(TENUM), Convert.ToString(value));
         }
 
         return base.ConvertFrom(context, culture, value);
      }
 
 
      public override bool CanConvertTo(ITypeDescriptorContext context, 
         Type destinationType)
      {
         if (destinationType == typeof(TENUM))
            return true;
 
         return base.CanConvertTo(context, destinationType);
      }
 
 
      public override object ConvertTo(ITypeDescriptorContext context, 
         System.Globalization.CultureInfo culture, object value, Type destinationType)
      {
         if (value != null && value.GetType() == typeof(TENUM))
         {
            System.Reflection.MemberInfo[] mi = 
               ((TENUM)value).GetType().GetMember(value.ToString());
 
            Object[] attributes = mi[0].GetCustomAttributes(typeof(TATTR), false);
 
            if (attributes.Length > 0)
               return ((TATTR)attributes[0]).Name;
            else
               return Convert.ToString(value);
         }
 
         return base.ConvertTo(context, culture, value, destinationType);
      }
 
   }
   #endregion
}
StringConverter
Enum

Managed Spy++

by lupok on mercoledì 19 febbraio 2014 11:02
Spy++

SharpDX: creare un cubo ed applicare zoom e rotazione

by lupok on domenica 16 febbraio 2014 18:34

In questo esempio vengono caricati i vertici di un cubo e mediante mouse vengono applicate trasformazione per ruotare e scalare l'oggetto 3D. 

Per visualizzare e gestire la visualizzazione del solido creato viene utilizzata la classe Game, le operazioni di rotazione e zoom avvengono intercettando i movimenti del mouse mediante i messaggi tradizionali di windows ed alternativamente mediante DirectInput. 

Per relalizzare questo esempio e' stata utilizzata la versione 2.5.0 di SharpDX, SharpDX e' una libreria fondata su DirectX o meglio e' un wrapper per .NET delle DirectX. 

 

DirectX
SharpDX
DirectInput
Game

Pianificare l'esecuzione di operazioni mediante Quartz.NET

by lupok on domenica 16 febbraio 2014 04:16

Quartz.NET e' una libreria utile per pianificare l'esecuzione di operazioni ad istanti temporali predefiniti. Per creare un'operazione pianificabile e' necessario: 

  1. Creare uno Scheduler, ovvero l'oggetto responsabile dell'esecuzione delle operazioni al verificarsi delle condizioni stabilite.
  2. Creare un Job, ovvero l'operazione da eseguire al verificarsi delle condizioni. Dal punto di vista informatico occorre creare una classe che implementa l'interfaccia Quartz.IJob. 
  3. Creare un Trigger, ovvero l'oggetto che determina il momento in cui una determinata operazione deve essere eseguita. 

Creo il Job:

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Quartz;
using Quartz.Impl;
 
namespace TestQuartz
{
   public class MyJob : IJob
   {
      public void Execute(IJobExecutionContext context)
      {
         Console.WriteLine("MyJob Execute: {0}", context.JobDetail.Key);
      }
   }
}

Quartz.NET

Use ASP.NET SqlMemberShipProvider in WCF self-hosted service with SSL

by lupok on giovedì 30 gennaio 2014 03:35

Questo articolo e' una estensione del precedente Use ASP.NET SqlMemberShipProvider in WCF self-hosted service in cui viene abilitato il supporto SSL per garantire la sicurezza delle informazioni. Per informazioni su come installare in supporto SSL su un servizio WCF self-hosted si rimanda all'articolo Configurare un servizio WCF WebHttpBinding self hosted con SSL.

 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Permissions;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using System.Text;
 
namespace WcfServiceHTTPSSelfHosted
{
   public class WcfServiceHTTPSSelfHosted : IWcfServiceHTTPSSelfHosted
   {
      [PrincipalPermission(SecurityAction.Demand, Role = "Managers")]
      public string GetData1(int value)
      {
         return string.Format("GetData1 you entered: {0}", value);
      }
 
      public string GetData2(int value)
      {
         if (System.Web.Security.Roles.IsUserInRole("Registered Users"))
         {
            return string.Format("GetData2 you entered: {0}", value);
         }
         else
         {
            throw new Exception("Role validation failed");
         }
      }
 
      public string GetData3(int value)
      {
         return string.Format("GetData3 you entered: {0}", value);
      }
   }
}
WCf
SSL
SqlMemberShipProvider

Use ASP.NET SqlMemberShipProvider in WCF self-hosted service

by lupok on martedì 28 gennaio 2014 13:43

L'utilizzo dei meccanismi di autenticazione di ASP.NET in WCF risulta essere molto comodo per gestire l'autenticazione degli utenti che voglioni accedere al servizio mediante i costrutti di base che in generale .NET mette a disposizione gestire le autorizzazioni all'esecuzione di porzioni di codice differenti. 

Questo esempio e' realizzato mediante webHttpBinding e basicHttpBinding in quanto i piu' utilizzati ma anche i piu' ostici per via dei numerosi vincoli imposti dalla tecnologia su cui sono basati. Il provider ASP.NET che viene utilizzato e' il SqlMemberShipProvider, quindi e' necessario creare un database utile a contenere tutte le tabelle di gestione utenti, ruoli, diritti, ecc...

 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Permissions;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using System.Text;
 
namespace WcfServiceHTTPSelfHosted
{
   public class WcfServiceHTTPSelfHosted : IWcfServiceHTTPSelfHosted
   {
      [PrincipalPermission(SecurityAction.Demand, Role = "Managers")]
      public string GetData1(int value)
      {
         return string.Format("GetData1 you entered: {0}", value);
      }
 
      public string GetData2(int value)
      {
         if (System.Web.Security.Roles.IsUserInRole("Registered Users"))
         {
            return string.Format("GetData2 you entered: {0}", value);
         }
         else
         {
            throw new Exception("Role validation failed");
         }
      }
 
      public string GetData3(int value)
      {
         return string.Format("GetData3 you entered: {0}", value);
      }
   }
}
WCf
SqlMemberShipProvider

Tags