internal static InstantiateObject GetFastObjectCreationDelegate(Type t)
{
// Look for the factory class in the same assembly
Assembly a = t.Assembly;
string shortAssemblyName = Util.GetAssemblyShortName(t.Assembly);
shortAssemblyName = shortAssemblyName.ToLower(CultureInfo.InvariantCulture);
Type factoryType = a.GetType(factoryFullClassNameBase + Util.MakeValidTypeNameFromString(shortAssemblyName));
if (factoryType == null)
{
return(null);
}
string methodName = GetCreateMethodNameForType(t.FullName);
try {
return((InstantiateObject)Delegate.CreateDelegate(
typeof(InstantiateObject), factoryType, methodName));
}
catch {
return(null);
}
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
// Get the namespace that we will use
string ns = Util.GetNamespaceFromVirtualPath(VirtualPathObject);
ServiceDescription sd;
// Load the wsdl file
using (Stream stream = VirtualPathObject.OpenFile()) {
try {
sd = ServiceDescription.Read(stream);
}
catch (InvalidOperationException e) {
// It can throw an InvalidOperationException, with the relevant
// XmlException as the inner exception. If so, throw that instead.
XmlException xmlException = e.InnerException as XmlException;
if (xmlException != null)
{
throw xmlException;
}
throw;
}
}
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
#if !FEATURE_PAL
importer.CodeGenerator = assemblyBuilder.CodeDomProvider;
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties |
CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateOldAsync;
#endif // !FEATURE_PAL
importer.ServiceDescriptions.Add(sd);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(ns);
codeCompileUnit.Namespaces.Add(codeNamespace);
// Create the code compile unit
importer.Import(codeNamespace, codeCompileUnit);
// Add the CodeCompileUnit to the compilation
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
}
internal ObjectFactoryCodeDomTreeGenerator(string outputAssemblyName)
{
_codeCompileUnit = new CodeCompileUnit();
CodeNamespace sourceDataNamespace = new CodeNamespace(
BaseCodeDomTreeGenerator.internalAspNamespace);
_codeCompileUnit.Namespaces.Add(sourceDataNamespace);
// Make the class name vary based on the assembly (VSWhidbey 363214)
string factoryClassName = factoryClassNameBase +
Util.MakeValidTypeNameFromString(outputAssemblyName).ToLower(CultureInfo.InvariantCulture);
// Create a single class, in which a method will be added for each
// type that needs to be fast created in this assembly
_factoryClass = new CodeTypeDeclaration(factoryClassName);
// Make the class internal (VSWhidbey 363214)
_factoryClass.TypeAttributes &= ~TypeAttributes.Public;
// We generate a dummy line pragma, just so it will end with a '#line hidden'
// and prevent the following generated code from ever being treated as user
// code. We need to use this hack because CodeDOM doesn't allow simply generating
// a '#line hidden'. (VSWhidbey 199384)
CodeSnippetTypeMember dummySnippet = new CodeSnippetTypeMember(String.Empty);
#if !PLATFORM_UNIX /// Unix file system
// CORIOLISTODO: Unix file system
dummySnippet.LinePragma = new CodeLinePragma(@"c:\\dummy.txt", 1);
#else // !PLATFORM_UNIX
dummySnippet.LinePragma = new CodeLinePragma(@"/dummy.txt", 1);
#endif // !PLATFORM_UNIX
_factoryClass.Members.Add(dummySnippet);
// Add a private default ctor to make the class non-instantiatable (VSWhidbey 340829)
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes |= MemberAttributes.Private;
_factoryClass.Members.Add(ctor);
sourceDataNamespace.Types.Add(_factoryClass);
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
#if !FEATURE_PAL // FEATURE_PAL does not support System.Data.Design
// Get the namespace that we will use
string ns = Util.GetNamespaceFromVirtualPath(VirtualPathObject);
// We need to use XmlDocument to parse the xsd file is order to open it with the
// correct encoding (VSWhidbey 566286)
XmlDocument doc = new XmlDocument();
using (Stream stream = OpenStream()) {
doc.Load(stream);
}
String content = doc.OuterXml;
// Generate a CodeCompileUnit from the dataset
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(ns);
codeCompileUnit.Namespaces.Add(codeNamespace);
// Devdiv 18365, Dev10
bool isVer35OrAbove = CompilationUtil.IsCompilerVersion35OrAbove(assemblyBuilder.CodeDomProvider.GetType());
if (isVer35OrAbove)
{
TypedDataSetGenerator.GenerateOption generateOptions = TypedDataSetGenerator.GenerateOption.None;
generateOptions |= TypedDataSetGenerator.GenerateOption.HierarchicalUpdate;
generateOptions |= TypedDataSetGenerator.GenerateOption.LinqOverTypedDatasets;
Hashtable customDBProviders = null;
TypedDataSetGenerator.Generate(content, codeCompileUnit, codeNamespace, assemblyBuilder.CodeDomProvider, customDBProviders, generateOptions);
}
else
{
TypedDataSetGenerator.Generate(content, codeCompileUnit, codeNamespace, assemblyBuilder.CodeDomProvider);
}
// Add all the assembly references needed by the generated code
if (TypedDataSetGenerator.ReferencedAssemblies != null)
{
var isVer35 = CompilationUtil.IsCompilerVersion35(assemblyBuilder.CodeDomProvider.GetType());
foreach (Assembly a in TypedDataSetGenerator.ReferencedAssemblies)
{
if (isVer35)
{
var aName = a.GetName();
if (aName.Name == "System.Data.DataSetExtensions")
{
// Dev10
aName.Version = new Version(3, 5, 0, 0);
CompilationSection.RecordAssembly(aName.FullName, a);
}
}
assemblyBuilder.AddAssemblyReference(a);
}
}
// Add the CodeCompileUnit to the compilation
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
#else // !FEATURE_PAL
throw new NotImplementedException("System.Data.Design - ROTORTODO");
#endif // !FEATURE_PAL
}
private static string GetCreateMethodNameForType(string typeToCreate)
{
return("Create_" + Util.MakeValidTypeNameFromString(typeToCreate));
}
