resets

Author: gewarren

snippets/cpp/VS_Snippets_CLR/ADDynamicBase/CPP/addynamicbase.cpp

@@ -0,0 +1,107 @@
+//<Snippet1>
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Reflection::Emit;
+
+public ref class Example : MarshalByRefObject
+{
+public:
+   void Test()
+   {
+      Assembly^ dynAssem = Assembly::Load(
+         "DynamicHelloWorld, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
+
+      Type^ myType = dynAssem->GetType("HelloWorld");
+      myType->InvokeMember("HelloFromAD", BindingFlags::Public | 
+         BindingFlags::Static | BindingFlags::InvokeMethod, 
+         Type::DefaultBinder, nullptr, nullptr);
+   }
+};
+
+
+static void GenerateDynamicAssembly(String^ location)
+{
+   // Define the dynamic assembly and the module. There is only one
+   // module in this assembly. Note that the call to DefineDynamicAssembly 
+   // specifies the location where the assembly will be saved. The 
+   // assembly version is 1.0.0.0.
+   //
+   AssemblyName^ asmName = gcnew AssemblyName("DynamicHelloWorld");
+   asmName->Version = gcnew Version("1.0.0.0");
+
+   AssemblyBuilder^ ab = 
+      AppDomain::CurrentDomain->DefineDynamicAssembly( 
+         asmName, AssemblyBuilderAccess::Save, location);
+
+   String^ moduleName = asmName->Name + ".exe";
+   ModuleBuilder^ mb = ab->DefineDynamicModule(asmName->Name, moduleName);
+   
+   // Define the "HelloWorld" type, with one static method.
+   TypeBuilder^ tb = mb->DefineType("HelloWorld", TypeAttributes::Public);
+   MethodBuilder^ hello = tb->DefineMethod("HelloFromAD", 
+      MethodAttributes::Public | MethodAttributes::Static, nullptr, nullptr);
+
+   // The method displays a message that contains the name of the application
+   // domain where the method is executed.
+   ILGenerator^ il = hello->GetILGenerator();
+   il->Emit(OpCodes::Ldstr, "Hello from '{0}'!");
+   il->Emit(OpCodes::Call, AppDomain::typeid->GetProperty("CurrentDomain")->GetGetMethod());
+   il->Emit(OpCodes::Call, AppDomain::typeid->GetProperty("FriendlyName")->GetGetMethod());
+   il->Emit(OpCodes::Call, Console::typeid->GetMethod("WriteLine", 
+                            gcnew array<Type^> { String::typeid, String::typeid }));
+   il->Emit(OpCodes::Ret);
+
+   // Complete the HelloWorld type and save the assembly. The assembly
+   // is placed in the location specified by DefineDynamicAssembly.
+   Type^ myType = tb->CreateType();
+   ab->Save(moduleName);
+};
+
+void main()
+{
+   // Prepare to create a new application domain.
+   AppDomainSetup^ setup = gcnew AppDomainSetup();
+
+   // Set the application name before setting the dynamic base.
+   setup->ApplicationName = "Example";
+   
+   // Set the location of the base directory where assembly resolution 
+   // probes for dynamic assemblies. Note that the hash code of the 
+   // application name is concatenated to the base directory name you 
+   // supply. 
+   setup->DynamicBase = "C:\\DynamicAssemblyDir";
+   Console::WriteLine("DynamicBase is set to '{0}'.", setup->DynamicBase);
+
+   AppDomain^ ad = AppDomain::CreateDomain("MyDomain", nullptr, setup);
+   
+   // The dynamic directory name is the dynamic base concatenated with
+   // the application name: <DynamicBase>\<hash code>\<ApplicationName>
+   String^ dynamicDir = ad->DynamicDirectory;
+   Console::WriteLine("Dynamic directory is '{0}'.", dynamicDir);
+
+   // The AssemblyBuilder won't create this directory automatically.
+   if (!System::IO::Directory::Exists(dynamicDir))
+   {
+      Console::WriteLine("Creating the dynamic directory.");
+      System::IO::Directory::CreateDirectory(dynamicDir);
+   }
+
+   // Generate a dynamic assembly and store it in the dynamic 
+   // directory.
+   GenerateDynamicAssembly(dynamicDir);
+
+   // Create an instance of the Example class in the application domain,
+   // and call its Test method to load the dynamic assembly and use it.
+   Example^ ex = (Example^) ad->CreateInstanceAndUnwrap( 
+         Example::typeid->Assembly->FullName, "Example");
+   ex->Test();
+}
+
+/* This example produces output similar to the following:
+
+DynamicBase is set to 'C:\DynamicAssemblyDir\5e4a7545'.
+Dynamic directory is 'C:\DynamicAssemblyDir\5e4a7545\Example'.
+Creating the dynamic directory.
+Hello from 'MyDomain'!
+ */
+//</Snippet1>

snippets/cpp/VS_Snippets_CLR/AppDomain_CreateInstance_IgnoreCase/CPP/ignorecase.cpp

@@ -0,0 +1,35 @@
+
+// <Snippet1>
+using namespace System;
+using namespace System::Reflection;
+static void InstantiateINT32( bool ignoreCase )
+{
+   try
+   {
+      AppDomain^ currentDomain = AppDomain::CurrentDomain;
+      Object^ instance = currentDomain->CreateInstanceAndUnwrap( 
+         "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", 
+         "SYSTEM.INT32", 
+         ignoreCase, 
+         BindingFlags::Default, 
+         nullptr, 
+         nullptr, 
+         nullptr, 
+         nullptr, 
+         nullptr );
+      Console::WriteLine( instance->GetType() );
+   }
+   catch ( TypeLoadException^ e ) 
+   {
+      Console::WriteLine( e->Message );
+   }
+
+}
+
+int main()
+{
+   InstantiateINT32( false ); // Failed!
+   InstantiateINT32( true ); // OK!
+}
+
+// </Snippet1>

snippets/cpp/VS_Snippets_CLR/AppDomain_DefineDynamicAssembly/CPP/definedynamicassembly.cpp

@@ -0,0 +1,56 @@
+
+// <Snippet1>
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Reflection::Emit;
+ref class Test
+{
+public:
+   static void InstantiateMyDynamicType( AppDomain^ domain )
+   {
+      try
+      {
+         
+         // You must supply a valid fully qualified assembly name here.
+         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
+      }
+      catch ( Exception^ e ) 
+      {
+         Console::WriteLine( e->Message );
+      }
+
+   }
+
+   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
+   {
+      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
+   }
+
+   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
+   {
+      
+      // Build a dynamic assembly using Reflection Emit API.
+      AssemblyName^ assemblyName = gcnew AssemblyName;
+      assemblyName->Name = "MyDynamicAssembly";
+      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
+      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
+      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
+      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
+      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
+      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
+      ilGenerator->Emit( OpCodes::Ret );
+      typeBuilder->CreateType();
+      return assemblyBuilder;
+   }
+
+};
+
+int main()
+{
+   AppDomain^ currentDomain = AppDomain::CurrentDomain;
+   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
+   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
+   Test::InstantiateMyDynamicType( currentDomain ); // OK!
+}
+
+// </Snippet1>

snippets/cpp/VS_Snippets_CLR/AppDomain_ExecuteAssembly/CPP/executeassembly.cpp

@@ -0,0 +1,17 @@
+
+using namespace System;
+
+// <Snippet1>
+int main()
+{
+   AppDomain^ currentDomain = AppDomain::CurrentDomain;
+   AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
+   currentDomain->ExecuteAssembly( "MyExecutable.exe" );
+   
+   // Prints S"MyExecutable running on [default]"
+   otherDomain->ExecuteAssembly( "MyExecutable.exe" );
+   
+   // Prints S"MyExecutable running on otherDomain"
+}
+
+// </Snippet1>

snippets/cpp/VS_Snippets_CLR/AppDomain_LoadRaw/CPP/loadraw.cpp

@@ -0,0 +1,77 @@
+
+// <Snippet1>
+using namespace System;
+using namespace System::IO;
+using namespace System::Reflection;
+using namespace System::Reflection::Emit;
+void InstantiateMyType( AppDomain^ domain )
+{
+   try
+   {
+      
+      // You must supply a valid fully qualified assembly name here.
+      domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyType" );
+   }
+   catch ( Exception^ e ) 
+   {
+      Console::WriteLine( e->Message );
+   }
+
+}
+
+
+// Loads the content of a file to a Byte array.
+array<Byte>^ loadFile( String^ filename )
+{
+   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
+   array<Byte>^buffer = gcnew array<Byte>((int)fs->Length);
+   fs->Read( buffer, 0, buffer->Length );
+   fs->Close();
+   return buffer;
+}
+
+
+// Creates a dynamic assembly with symbol information
+// and saves them to temp.dll and temp.pdb
+void EmitAssembly( AppDomain^ domain )
+{
+   AssemblyName^ assemblyName = gcnew AssemblyName;
+   assemblyName->Name = "MyAssembly";
+   AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Save );
+   ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyModule", "temp.dll", true );
+   TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyType", TypeAttributes::Public );
+   ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
+   ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
+   ilGenerator->EmitWriteLine( "MyType instantiated!" );
+   ilGenerator->Emit( OpCodes::Ret );
+   typeBuilder->CreateType();
+   assemblyBuilder->Save( "temp.dll" );
+}
+
+ref class Resolver
+{
+public:
+   static Assembly^ MyResolver( Object^ sender, ResolveEventArgs^ args )
+   {
+      AppDomain^ domain = dynamic_cast<AppDomain^>(sender);
+      
+      // Once the files are generated, this call is
+      // actually no longer necessary.
+      EmitAssembly( domain );
+      array<Byte>^rawAssembly = loadFile( "temp.dll" );
+      array<Byte>^rawSymbolStore = loadFile( "temp.pdb" );
+      Assembly^ assembly = domain->Load( rawAssembly, rawSymbolStore );
+      return assembly;
+   }
+
+};
+
+int main()
+{
+   AppDomain^ currentDomain = AppDomain::CurrentDomain;
+   InstantiateMyType( currentDomain ); // Failed!
+   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Resolver::MyResolver );
+   InstantiateMyType( currentDomain ); // OK!
+}
+
+// </Snippet1>

snippets/cpp/VS_Snippets_Remoting/MessageQueue.GetMessageEnumerator/CPP/mqgetmessageenumerator.cpp

@@ -0,0 +1,55 @@
+
+
+// <Snippet1>
+#using <system.dll>
+#using <system.messaging.dll>
+
+using namespace System;
+using namespace System::Messaging;
+ref class MyNewQueue
+{
+public:
+   void CountLowestPriority()
+   {
+      
+      // Holds the count of Lowest priority messages.
+      UInt32 numberItems = 0;
+      
+      // Connect to a queue.
+      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
+      
+      // Get a cursor into the messages in the queue.
+      MessageEnumerator^ myEnumerator = myQueue->GetMessageEnumerator();
+      
+      // Specify that the messages's priority should be read.
+      myQueue->MessageReadPropertyFilter->Priority = true;
+      
+      // Move to the next message and examine its priority.
+      while ( myEnumerator->MoveNext() )
+      {
+         
+         // Increase the count if priority is Lowest.
+         if ( myEnumerator->Current->Priority == MessagePriority::Lowest )
+                  numberItems++;
+      }
+
+      
+      // Display final count.
+      Console::WriteLine( "Lowest priority messages: {0}", numberItems );
+      return;
+   }
+
+};
+
+int main()
+{
+   
+   // Create a new instance of the class.
+   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
+   
+   // Output the count of Lowest priority messages.
+   myNewQueue->CountLowestPriority();
+   return 0;
+}
+
+// </Snippet1>