public SimpleCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
: base(className, rootNamespaceName, sourceFileName, host)
{
var baseType = new CodeTypeReference(SimpleRazorConfiguration.BaseClass);
Context.GeneratedClass.BaseTypes.Clear();
Context.GeneratedClass.BaseTypes.Add(baseType);
}
public void SetTestFixtureSetup(CodeMemberMethod fixtureSetupMethod)
{
// xUnit uses IUseFixture<T> on the class
fixtureSetupMethod.Attributes |= MemberAttributes.Static;
_currentFixtureTypeDeclaration = new CodeTypeDeclaration("FixtureData");
_currentTestTypeDeclaration.Members.Add(_currentFixtureTypeDeclaration);
var fixtureDataType =
CodeDomHelper.CreateNestedTypeReference(_currentTestTypeDeclaration, _currentFixtureTypeDeclaration.Name);
var useFixtureType = new CodeTypeReference(IUSEFIXTURE_INTERFACE, fixtureDataType);
CodeDomHelper.SetTypeReferenceAsInterface(useFixtureType);
_currentTestTypeDeclaration.BaseTypes.Add(useFixtureType);
// public void SetFixture(T) { } // explicit interface implementation for generic interfaces does not work with codedom
CodeMemberMethod setFixtureMethod = new CodeMemberMethod();
setFixtureMethod.Attributes = MemberAttributes.Public;
setFixtureMethod.Name = "SetFixture";
setFixtureMethod.Parameters.Add(new CodeParameterDeclarationExpression(fixtureDataType, "fixtureData"));
setFixtureMethod.ImplementationTypes.Add(useFixtureType);
_currentTestTypeDeclaration.Members.Add(setFixtureMethod);
// public <_currentFixtureTypeDeclaration>() { <fixtureSetupMethod>(); }
CodeConstructor ctorMethod = new CodeConstructor();
ctorMethod.Attributes = MemberAttributes.Public;
_currentFixtureTypeDeclaration.Members.Add(ctorMethod);
ctorMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(_currentTestTypeDeclaration.Name)),
fixtureSetupMethod.Name));
}
internal CodeTypeMemberCollection GenerateParameterProperty(IParameter parameter,
IMethod method,
CodeTypeDeclaration resourceClass,
IEnumerable<string> usedNames)
{
// Get the name and return type of this parameter.
string name = parameter.Name;
CodeTypeReference returnType = ResourceBaseGenerator.GetParameterTypeReference(
resourceClass, parameter);
// Generate the property and field.
CodeTypeMemberCollection newMembers = DecoratorUtil.CreateAutoProperty(
name, parameter.Description, returnType, usedNames, parameter.IsRequired);
// Add the KeyAttribute to the property.
foreach (CodeTypeMember member in newMembers)
{
CodeMemberProperty property = member as CodeMemberProperty;
if (property == null)
{
continue;
}
// Declare the RequestParameter attribute.
CodeTypeReference attributeType = new CodeTypeReference(typeof(RequestParameterAttribute));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(attributeType);
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(parameter.Name)));
property.CustomAttributes.Add(attribute);
}
return newMembers;
}
public void Visit(BufferTable table)
{
var descriptor = new TableDescriptor(typeof(BufferTable<>));
var bufferTable = new CodeTypeDeclaration(table.Variable) { TypeAttributes = TypeAttributes.NestedPrivate };
bufferTable.BaseTypes.Add(new CodeTypeReference("IRow"));
var bufferCodeDomType = new CodeTypeReference("CodeTable", new CodeTypeReference(table.Variable));
Scope.Current.Type.Type.Members.Add(
new CodeMemberField(bufferCodeDomType, table.Variable) { Attributes = MemberAttributes.Public | MemberAttributes.Final });
Scope.Current.Type.Constructor.Statements.Add(new CodeAssignStatement(
new CodeSnippetExpression(table.Variable),
new CodeObjectCreateExpression(
new CodeTypeReference("BufferTable", new CodeTypeReference(table.Variable)))));
foreach (var arg in table.Args)
{
var domArg = VisitChild(arg);
bufferTable.Members.AddRange(domArg.ParentMemberDefinitions);
descriptor.Variables.Add(new VariableTypePair { Variable = arg.Variable, Primitive = TablePrimitive.FromString(arg.Type) });
}
_mainType.Type.Members.Add(bufferTable);
if (Scope.Current.IsCurrentScopeRegistered(table.Variable))
Errors.Add(new VariableAlreadyExists(new Semantic.LineInfo(table.Line.Line, table.Line.CharacterPosition), table.Variable));
Scope.Current.RegisterTable(table.Variable, descriptor, bufferCodeDomType);
}
internal static CodeTypeReference GetParameterTypeReference(CodeTypeDeclaration classDeclaration,
IParameter param)
{
Type underlyingType = GetParameterType(param);
CodeTypeReference paramTypeRef = new CodeTypeReference(underlyingType);
bool isValueType = underlyingType.IsValueType;
// Check if we need to declare a custom type for this parameter.
// If the parameter is an enum, try finding the matching enumeration in the current class
if (!param.EnumValues.IsNullOrEmpty())
{
// Naming scheme: MethodnameParametername
CodeTypeReference enumReference = DecoratorUtil.FindFittingEnumeration(
classDeclaration, param.EnumValues, param.EnumValueDescriptions);
if (enumReference != null)
{
paramTypeRef = enumReference;
isValueType = true;
}
}
// Check if this is an optional value parameter.
if (isValueType && !param.IsRequired)
{
paramTypeRef = new CodeTypeReference(typeof(Nullable<>))
{
TypeArguments = { paramTypeRef.BaseType }
};
// An optional value parameter has to be nullable.
}
return paramTypeRef;
}
public string GetTypeOutput(CodeTypeReference type)
{
if (!_baseTypeRegex.IsMatch(type.BaseType))
throw new ArgumentException("Type mismatch");
var baseTypeName = _baseTypeRegex
.Match(type.BaseType)
.Groups["TypeName"]
.Captures[0]
.Value;
string typeOutputString;
if (baseTypeName.Contains("Nullable"))
{
typeOutputString = GetTypeArgument(type);
}
else
{
typeOutputString = TranslateType(baseTypeName);
if (type.TypeArguments.Count > 0)
typeOutputString = AddTypeArguments(type, typeOutputString);
}
if (_arrayRegex.IsMatch(type.BaseType))
typeOutputString = GetArrayType(type.BaseType, typeOutputString);
else if (type.ArrayRank > 0)
typeOutputString = GetArrayString(typeOutputString, type.ArrayRank);
return typeOutputString;
}
protected override void ProcessProperty(CodeTypeDeclaration type, CodeMemberField field, CodeMemberProperty property)
{
if (property.Type.ArrayElementType == null) return; // Is array?
if (property.Name == "Items" || property.Name == "ItemsElementName") return;
CodeTypeReference genericType = new CodeTypeReference("System.Collections.Generic.List", new CodeTypeReference(property.Type.BaseType));
property.Type = genericType;
if (field != null) {
field.Type = genericType;
property.GetStatements.Insert(0,
// if
new CodeConditionStatement(
// field == null
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
// field = new List<T>();
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
new CodeObjectCreateExpression(genericType))));
}
}
/// <summary>
/// Initializes a new instance of the CodeCreateAndInitializeObjectExpression class.
/// </summary>
/// <param name="objectType">The object type.</param>
/// <param name="constructorParameters">The constructor parameters.</param>
public CodeCreateAndInitializeObjectExpression(CodeTypeReference objectType, params CodeExpression[] constructorParameters)
{
this.ObjectType = objectType;
this.ConstructorParameters = new CodeExpressionCollection();
this.ConstructorParameters.AddRange(constructorParameters);
this.PropertyInitializers = new List<KeyValuePair<string, CodeExpression>>();
}
private void EmitField(CodeTypeDeclaration typeDecl, CodeTypeReference fieldType, bool hasDefault)
{
CodeMemberField memberField = new CodeMemberField(fieldType, Utils.FieldNameFromPropName(Item.Name));
memberField.Attributes = MemberAttributes.Private;
AttributeEmitter.AddGeneratedCodeAttribute(memberField);
if (hasDefault)
{
if (this.Generator.UseDataServiceCollection)
{
// new DataServiceCollection<T>(null, System.Data.Services.Client.TrackingMode.None, null, null, null);
// declare type is DataServiceCollection<T>
Debug.Assert(fieldType.TypeArguments.Count == 1, "Declare type is non generic.");
// new DataServiceCollection<[type]>(null, TrackingMode.None)
memberField.InitExpression = new CodeObjectCreateExpression(
fieldType,
new CodePrimitiveExpression(null),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(System.Data.Services.Client.TrackingMode)),
"None"));
}
else
{
memberField.InitExpression = new CodeObjectCreateExpression(fieldType);
}
}
typeDecl.Members.Add(memberField);
}
protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
{
CodeTypeReference reference;
if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference)))
{
return null;
}
if (string.IsNullOrEmpty(value) || base.IsValidCompactAttributeFormat(value))
{
return null;
}
try
{
Type type = serializationManager.GetType(value);
if (type != null)
{
reference = new CodeTypeReference(type);
reference.UserData["QualifiedName"] = type.AssemblyQualifiedName;
return reference;
}
}
catch (Exception)
{
}
reference = new CodeTypeReference(value);
reference.UserData["QualifiedName"] = value;
return reference;
}
private CodeTypeReference ComputeForType(Type type)
{
// we know that we can safely global:: qualify this because it was already
// compiled before we are emitting or else we wouldn't have a Type object
CodeTypeReference value = new CodeTypeReference(type, CodeTypeReferenceOptions.GlobalReference);
return value;
}
public override void Visit(ViewTreeNode node)
{
if (typeStack.Count == 0) return;
var constructionArguments = new CodeExpression[]
{
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), naming.ToMemberVariableName(serviceIdentifier)),
new CodeTypeOfExpression(node.Controller.FullName),
new CodePrimitiveExpression(node.Controller.Area),
new CodePrimitiveExpression(naming.ToControllerName(node.Controller.Name)),
new CodePrimitiveExpression(node.Name)
};
CodeExpression returnExpression =
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), naming.ToMemberVariableName(serviceIdentifier)),
"ControllerReferenceFactory"),
"CreateViewReference"),
constructionArguments);
var propertyType = new CodeTypeReference(typeof (IControllerViewReference));
typeStack.Peek().Members.Add(source.CreateReadOnlyProperty(node.Name, propertyType, returnExpression));
base.Visit(node);
}
private static string ConvertTypeReferenceToString(CodeTypeReference reference)
{
StringBuilder builder;
if (reference.ArrayElementType != null)
{
builder = new StringBuilder(ConvertTypeReferenceToString(reference.ArrayElementType));
if (reference.ArrayRank > 0)
{
builder.Append("[");
builder.Append(',', reference.ArrayRank - 1);
builder.Append("]");
}
}
else
{
builder = new StringBuilder(reference.BaseType);
if ((reference.TypeArguments != null) && (reference.TypeArguments.Count > 0))
{
string str = "[";
foreach (CodeTypeReference reference2 in reference.TypeArguments)
{
builder.Append(str);
builder.Append(ConvertTypeReferenceToString(reference2));
str = ", ";
}
builder.Append("]");
}
}
return builder.ToString();
}
public string GetTypeOutput(CodeTypeReference type)
{
var name = new StringBuilder(type.BaseType.Length + type.ArrayRank * 2);
string basename = type.BaseType;
int z = basename.IndexOf('`');
if (z != -1)
basename = basename.Substring(0, z);
name.Append(basename);
if (type.TypeArguments.Count > 0)
{
name.Append('<');
for (int i = 0; i < type.TypeArguments.Count; i++)
{
name.Append(GetTypeOutput(type.TypeArguments[i]));
if (i > 0)
name.Append(", ");
}
name.Append('>');
}
for (int i = 0; i < type.ArrayRank; i++)
name.Append("[]");
return name.ToString();
}
private void SetBaseType(string modelTypeName)
{
var baseClass = StringExtensions.SplitOnFirst((string) Host.DefaultBaseClass, (char) '<')[0];
var baseType = new CodeTypeReference(baseClass + "<" + modelTypeName + ">");
GeneratedClass.BaseTypes.Clear();
GeneratedClass.BaseTypes.Add(baseType);
}
public void AddRange(CodeTypeReference[] value)
{
foreach(CodeTypeReference e in value)
{
List.Add(e);
}
}
protected override CodeTypeDeclaration BeginClass ()
{
CodeTypeDeclaration codeClass = base.BeginClass ();
CodeTypeReference ctr = new CodeTypeReference ("System.Web.Services.Protocols.HttpPostClientProtocol");
codeClass.BaseTypes.Add (ctr);
return codeClass;
}
// Generates a codedom instantiation expression: new foo() or new foo[x].
public static CodeExpression Emit(Instantiation instantiation)
{
// Array instantiation needs a different treatment.
if (instantiation.IsArray)
{
var c = new CodeArrayCreateExpression();
c.CreateType = new CodeTypeReference(instantiation.Name);
c.SizeExpression = CodeDomEmitter.EmitCodeExpression(instantiation.Parameters.ChildExpressions[0]);
return c;
}
else // Non-array instantiation
{
var c = new CodeObjectCreateExpression();
// The type that is being created
var createType = new CodeTypeReference(instantiation.Name);
// Apply the generic type names, if any.
foreach (var g in instantiation.GenericTypes)
{
createType.TypeArguments.Add(new CodeTypeReference(g));
}
c.CreateType = createType;
// Translate the instantiation parameters.
foreach (var a in instantiation.Parameters.ChildExpressions)
c.Parameters.Add(CodeDomEmitter.EmitCodeExpression(a));
return c;
}
}
CodeTypeDeclaration EmitClass()
{
CodeTypeDeclaration customSBConfigSectionClass = new CodeTypeDeclaration(generatedElementClassName);
CodeTypeReference baseClass = new CodeTypeReference(TypeNameConstants.StdBindingElement);
customSBConfigSectionClass.BaseTypes.Add(baseClass);
return customSBConfigSectionClass;
}
public void Visit(DownloadImageExpression expression)
{
var type = new CodeTypeReference("RuntimeTable", new CodeTypeReference("DownloadImage"));
DownloadImpl(expression.Statement, "DownloadImage", type, expression.Line.Line);
_codeStack.Peek().Scope = new ScopeData<TableDescriptor> { Type = DownloadImage.Columns, CodeDomReference = type };
}
public void Constructor1_Deny_Unrestricted ()
{
CodeTypeReference type = new CodeTypeReference ("System.Int32");
CodeTypeReferenceExpression ctre = new CodeTypeReferenceExpression (type);
Assert.AreSame (type, ctre.Type, "Type");
ctre.Type = new CodeTypeReference ("System.Void");
}
public void Constructor1_Deny_Unrestricted ()
{
CodeTypeReference ctr = new CodeTypeReference ();
CodeDefaultValueExpression cdve = new CodeDefaultValueExpression (ctr);
Assert.AreSame (ctr, cdve.Type, "Type");
cdve.Type = new CodeTypeReference ();
}
public void Constructor0 ()
{
CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression ();
Assert.IsNotNull (cpde.CustomAttributes, "#1");
Assert.AreEqual (0, cpde.CustomAttributes.Count, "#2");
Assert.AreEqual (FieldDirection.In, cpde.Direction, "#3");
Assert.IsNotNull (cpde.Name, "#4");
Assert.AreEqual (string.Empty, cpde.Name, "#5");
Assert.IsNotNull (cpde.Type, "#6");
Assert.AreEqual (typeof (void).FullName, cpde.Type.BaseType, "#7");
cpde.Direction = FieldDirection.Out;
Assert.AreEqual (FieldDirection.Out, cpde.Direction, "#8");
string name = "mono";
cpde.Name = name;
Assert.AreSame (name, cpde.Name, "#9");
cpde.Name = null;
Assert.IsNotNull (cpde.Name, "#10");
Assert.AreEqual (string.Empty, cpde.Name, "#11");
CodeTypeReference type = new CodeTypeReference ("mono");
cpde.Type = type;
Assert.AreSame (type, cpde.Type, "#12");
cpde.Type = null;
Assert.IsNotNull (cpde.Type, "#13");
Assert.AreEqual (typeof (void).FullName, cpde.Type.BaseType, "#14");
}
public CodeVariableDeclarationStatement(Type type, String name,
CodeExpression initExpression)
{
this.type = new CodeTypeReference(type);
this.name = name;
this.initExpression = initExpression;
}
internal BindingElementExtensionSectionGenerator(Type bindingElementType, Assembly userAssembly, CodeDomProvider provider)
{
this.bindingElementType = bindingElementType;
this.userAssembly = userAssembly;
this.provider = provider;
string typePrefix = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement));
this.generatedClassName = typePrefix + Constants.ElementSuffix;
this.constantsClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.ConfigurationStrings;
this.defaultValuesClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.Defaults;
this.customBEVarInstance = Helpers.TurnFirstCharLower(bindingElementType.Name);
customBEArgRef = new CodeArgumentReferenceExpression(customBEVarInstance);
this.customBETypeRef = new CodeTypeReference(bindingElementType.Name);
this.customBETypeOfRef = new CodeTypeOfExpression(customBETypeRef);
this.customBENewVarAssignRef = new CodeVariableDeclarationStatement(
customBETypeRef,
customBEVarInstance,
new CodeObjectCreateExpression(customBETypeRef));
this.bindingElementMethodParamRef = new CodeParameterDeclarationExpression(
CodeDomHelperObjects.bindingElementTypeRef,
Constants.bindingElementParamName);
}
public CodeAttributeDeclaration (CodeTypeReference attributeType)
{
attribute = attributeType;
if (attributeType != null) {
name = attributeType.BaseType;
}
}
public void Constructor1 ()
{
CodeTypeReference type1 = new CodeTypeReference ("mono1");
CodeExpression expression1 = new CodeExpression ();
CodeCastExpression cce = new CodeCastExpression (type1, expression1);
Assert.IsNotNull (cce.Expression, "#1");
Assert.AreSame (expression1, cce.Expression, "#2");
Assert.IsNotNull (cce.TargetType, "#3");
Assert.AreSame (type1, cce.TargetType, "#4");
cce.Expression = null;
Assert.IsNull (cce.Expression, "#5");
CodeExpression expression2 = new CodeExpression ();
cce.Expression = expression2;
Assert.IsNotNull (cce.Expression, "#6");
Assert.AreSame (expression2, cce.Expression, "#7");
cce.TargetType = null;
Assert.IsNotNull (cce.TargetType, "#8");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#9");
CodeTypeReference type2 = new CodeTypeReference ("mono2");
cce.TargetType = type2;
Assert.IsNotNull (cce.TargetType, "#10");
Assert.AreSame (type2, cce.TargetType, "#11");
cce = new CodeCastExpression ((CodeTypeReference) null, (CodeExpression) null);
Assert.IsNull (cce.Expression, "#12");
Assert.IsNotNull (cce.TargetType, "#13");
Assert.AreEqual (typeof (void).FullName, cce.TargetType.BaseType, "#14");
}
protected void ResourceCallAddBodyDeclaration(IMethod method,
CodeMemberMethod member,
CodeTypeReference bodyType,
bool addBodyIfUnused)
{
switch (method.HttpMethod)
{
case Request.GET:
case Request.DELETE:
if (!addBodyIfUnused)
{
break;
}
// string body = null;
var bodyVarDeclaration = new CodeVariableDeclarationStatement(bodyType, "body");
bodyVarDeclaration.InitExpression = new CodePrimitiveExpression(null);
member.Statements.Add(bodyVarDeclaration);
break;
case Request.PUT:
case Request.POST:
case Request.PATCH:
// add body Parameter.
member.Parameters.Add(new CodeParameterDeclarationExpression(bodyType, "body"));
break;
default:
throw new NotSupportedException("Unsupported HttpMethod [" + method.HttpMethod + "]");
}
}
/// <include file='doc\CodeTypeReference.uex' path='docs/doc[@for="CodeTypeReference.CodeTypeReference1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeTypeReference(string typeName) {
if (typeName == null || typeName.Length == 0) {
typeName = typeof(void).FullName;
}
// See if this ends with standard array tail. If is is not an exact match, we pass it through verbatim.
int lastArrayOpen = typeName.LastIndexOf('[');
int lastArrayClose = typeName.LastIndexOf(']');
bool isArray = lastArrayOpen >= 0 && lastArrayClose == (typeName.Length - 1) && lastArrayOpen < lastArrayClose;
if (isArray) {
for (int index = lastArrayOpen + 1; index < lastArrayClose; index++) {
if (typeName[index] != ',') {
isArray = false;
}
}
}
if (isArray) {
this.baseType = null;
this.arrayRank = lastArrayClose - lastArrayOpen;
this.arrayElementType = new CodeTypeReference(typeName.Substring(0, lastArrayOpen));
}
else {
this.baseType = typeName;
this.arrayRank = 0;
this.arrayElementType = null;
}
}
public void Constructor1 ()
{
CodeExpression expression = new CodeExpression ();
CodeTypeReference type = new CodeTypeReference ("mono");
string methodName = "mono";
CodeDelegateCreateExpression cdce = new CodeDelegateCreateExpression (
type, expression, methodName);
Assert.IsNotNull (cdce.DelegateType, "#1");
Assert.AreSame (type, cdce.DelegateType, "#2");
Assert.IsNotNull (cdce.MethodName, "#3");
Assert.AreSame (methodName, cdce.MethodName, "#4");
Assert.IsNotNull (cdce.TargetObject, "#5");
Assert.AreSame (expression, cdce.TargetObject, "#6");
cdce = new CodeDelegateCreateExpression ((CodeTypeReference) null,
(CodeExpression) null, (string) null);
Assert.IsNotNull (cdce.DelegateType, "#7");
Assert.AreEqual (typeof (void).FullName, cdce.DelegateType.BaseType, "#8");
Assert.IsNotNull (cdce.MethodName, "#9");
Assert.AreEqual (string.Empty, cdce.MethodName, "#10");
Assert.IsNull (cdce.TargetObject, "#11");
}
protected override void OutputType(System.CodeDom.CodeTypeReference typeRef)
{
if (!own_output && typeRef.BaseType != "System.Windows.Forms.ContextMenuStrip")
{
Output.Write(typeRef.BaseType.Replace("System.Windows.Forms.Label", "&Label").Replace("System.Windows.Forms.", ""));
}
else
{
Output.Write(typeRef.BaseType);
}
}
public CodeAttributeDeclaration(CodeTypeReference attributeType)
{
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeCatchClause(string localName, CodeTypeReference catchExceptionType)
{
this.localName = localName;
this.catchExceptionType = catchExceptionType;
}
protected override void OutputType(System.CodeDom.CodeTypeReference typeRef)
{
Output.Write(typeRef.BaseType);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeArrayCreateExpression(Type createType, int size)
{
this.createType = new CodeTypeReference(createType);
this.size = size;
}
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeArrayCreateExpression'/>. with the specified array
/// type and size.
/// </para>
/// </devdoc>
public CodeArrayCreateExpression(CodeTypeReference createType, int size)
{
this.createType = createType;
this.size = size;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeArrayCreateExpression(Type createType, params CodeExpression[] initializers)
{
this.createType = new CodeTypeReference(createType);
this.initializers.AddRange(initializers);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeArrayCreateExpression(string createType, CodeExpression size)
{
this.createType = new CodeTypeReference(createType);
this.sizeExpression = size;
}
protected override string GetTypeOutput(System.CodeDom.CodeTypeReference value)
{
throw new Exception("The method or operation is not implemented.");
}
public CodeParameterDeclarationExpression(Type type, string name)
{
this.type = new CodeTypeReference(type);
this.name = name;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeVariableDeclarationStatement(Type type, string name)
{
Type = new CodeTypeReference(type);
Name = name;
}
public CodeAttributeDeclaration(CodeTypeReference attributeType, CodeAttributeArgument[] arguments)
{
}
/// <include file='doc\CodeObjectCreateExpression.uex' path='docs/doc[@for="CodeObjectCreateExpression.CodeObjectCreateExpression3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeObjectCreateExpression(Type createType, params CodeExpression[] parameters)
{
CreateType = new CodeTypeReference(createType);
Parameters.AddRange(parameters);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeVariableDeclarationStatement(Type type, string name, CodeExpression initExpression)
{
Type = new CodeTypeReference(type);
Name = name;
InitExpression = initExpression;
}
/// <include file='doc\CodeTypeOfExpression.uex' path='docs/doc[@for="CodeTypeOfExpression.CodeTypeOfExpression1"]/*' />
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeTypeOfExpression'/>.
/// </para>
/// </devdoc>
public CodeTypeOfExpression(CodeTypeReference type)
{
Type = type;
}
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeVariableDeclarationStatement'/> using the specified type and name.
/// </para>
/// </devdoc>
public CodeVariableDeclarationStatement(CodeTypeReference type, string name)
{
Type = type;
Name = name;
}
public CodeTypeReferenceExpression(CodeTypeReference type)
{
this.type = type;
}
/// <include file='doc\CodeTypeOfExpression.uex' path='docs/doc[@for="CodeTypeOfExpression.CodeTypeOfExpression3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeTypeOfExpression(Type type)
{
Type = new CodeTypeReference(type);
}
public CodeCatchClause(string localName, CodeTypeReference catchExceptionType, params CodeStatement[] statements)
{
throw new NotImplementedException();
}
public CodeTypeReferenceExpression(Type type)
{
this.type = new CodeTypeReference(type);
}
public CodeObjectCreateExpression(ILInstruction inline, Type createType, params CodeExpression[] parameters) : base(inline)
{
CreateType = new CodeTypeReference(createType);
Parameters.AddRange(parameters);
}
public CodeTypeOfExpression(string type)
{
this.type = new CodeTypeReference(type);
}
/// <devdoc>
/// <para> Removes a specific <see cref='System.CodeDom.CodeTypeReference'/> from the
/// <see cref='System.CodeDom.CodeTypeReferenceCollection'/> .</para>
/// </devdoc>
public void Remove(CodeTypeReference value)
{
List.Remove(value);
}
public CodeCatchClause(string localName, CodeTypeReference catchExceptionType)
{
throw new NotImplementedException();
}
/// <devdoc>
/// <para>Returns the index of a <see cref='System.CodeDom.CodeTypeReference'/> in
/// the <see cref='System.CodeDom.CodeTypeReferenceCollection'/> .</para>
/// </devdoc>
public int IndexOf(CodeTypeReference value)
{
return(List.IndexOf(value));
}
/// <devdoc>
/// <para>Adds a <see cref='System.CodeDom.CodeTypeReference'/> with the specified value to the
/// <see cref='System.CodeDom.CodeTypeReferenceCollection'/> .</para>
/// </devdoc>
public int Add(CodeTypeReference value)
{
return(List.Add(value));
}
public CodeMemberField(Type type, String name)
{
this.type = new CodeTypeReference(type);
this.Name = name;
}
/// <devdoc>
/// <para>Inserts a <see cref='System.CodeDom.CodeTypeReference'/> into the <see cref='System.CodeDom.CodeTypeReferenceCollection'/> at the specified index.</para>
/// </devdoc>
public void Insert(int index, CodeTypeReference value)
{
List.Insert(index, value);
}
public CodeMemberField(CodeTypeReference type, String name)
{
this.type = type;
this.Name = name;
}
/// <devdoc>
/// <para>Gets a value indicating whether the
/// <see cref='System.CodeDom.CodeTypeReferenceCollection'/> contains the specified <see cref='System.CodeDom.CodeTypeReference'/>.</para>
/// </devdoc>
public bool Contains(CodeTypeReference value)
{
return(List.Contains(value));
}
