/// <summary>
/// Creates a set of FunctionImportParameter objects from the parameters passed in.
/// </summary>
public static IEnumerable<FunctionImportParameter> Create(IEnumerable<FunctionParameter> parameters, CodeGenerationTools code, MetadataTools ef)
{
if(parameters == null)
throw new ArgumentNullException("parameters");
if(code == null)
throw new ArgumentNullException("code");
if(ef == null)
throw new ArgumentNullException("ef");
var unique = new UniqueIdentifierService();
var importParameters = new List<FunctionImportParameter>();
foreach(var parameter in parameters)
{
var importParameter = new FunctionImportParameter();
importParameter.Source = parameter;
importParameter.RawFunctionParameterName = unique.AdjustIdentifier(code.CamelCase(parameter.Name));
importParameter.FunctionParameterName = code.Escape(importParameter.RawFunctionParameterName);
if(parameter.Mode == ParameterMode.In)
{
importParameter.NeedsLocalVariable = true;
importParameter.FunctionParameterType = code.Escape(parameter.TypeUsage);
importParameter.EsqlParameterName = parameter.Name;
var clrType = ef.ClrType(parameter.TypeUsage);
importParameter.RawClrTypeName = code.Escape(clrType);
importParameter.IsNullableOfT = clrType.IsValueType;
}
else
{
importParameter.NeedsLocalVariable = false;
importParameter.FunctionParameterType = "ObjectParameter";
importParameter.ExecuteParameterName = importParameter.FunctionParameterName;
}
importParameters.Add(importParameter);
}
// we save the local parameter uniquification for a second pass to make the visible parameters
// as pretty and sensible as possible
for(var i = 0; i < importParameters.Count; i++)
{
var importParameter = importParameters[i];
if(importParameter.NeedsLocalVariable)
{
importParameter.LocalVariableName = unique.AdjustIdentifier(importParameter.RawFunctionParameterName + "Parameter");
importParameter.ExecuteParameterName = importParameter.LocalVariableName;
}
}
return importParameters;
}
private CodeExpression CreateFunctionParameter(CodeMemberMethod method, UniqueIdentifierService uniqueIdentifierService, FunctionParameter parameter)
{
// get (adjusted) name of parameter
string adjustedParameterName;
if (!uniqueIdentifierService.TryGetAdjustedName(parameter, out adjustedParameterName))
{
Debug.Fail("parameter must be registered in identifier service");
}
Type parameterType = DetermineParameterType(parameter);
// make sure the variable name does not collide with any parameters to the method, or any
// existing variables (all registered in the service)
string variableName = uniqueIdentifierService.AdjustIdentifier(parameter.Name + "Parameter");
// ObjectParameter variableName;
// if (null != parameterName)
// {
// variableName = new ObjectParameter("parameterName", adjustedParameterName);
// }
// else
// {
// variableName = new ObjectParameter("parameterName", typeof(parameterType));
// }
method.Statements.Add(
new CodeVariableDeclarationStatement(TypeReference.ForType(typeof(ObjectParameter)), variableName));
CodeExpression variableReference = new CodeVariableReferenceExpression(variableName);
CodeExpression parameterReference = new CodeVariableReferenceExpression(adjustedParameterName);
CodeStatement nullConstructor = new CodeAssignStatement(variableReference,
new CodeObjectCreateExpression(TypeReference.ForType(typeof(ObjectParameter)),
new CodePrimitiveExpression(parameter.Name),
new CodeTypeOfExpression(TypeReference.ForType(parameterType))));
CodeStatement valueConstructor = new CodeAssignStatement(variableReference,
new CodeObjectCreateExpression(TypeReference.ForType(typeof(ObjectParameter)),
new CodePrimitiveExpression(parameter.Name),
parameterReference));
CodeExpression notNullCondition;
if (parameterType.IsValueType)
{
// Value type parameters generate Nullable<ValueType> arguments (see CreateFunctionArgument).
// We call Nullable<ValueType>.HasValue to determine whether the argument passed in is null
// (since null != nullableTypeInstance does not work in VB)
//
// parameterReference.HasValue
notNullCondition = new CodePropertyReferenceExpression(
parameterReference,
"HasValue");
}
else
{
// use parameterReference != null
notNullCondition = new CodeBinaryOperatorExpression(
parameterReference,
CodeBinaryOperatorType.IdentityInequality,
NullExpression);
}
method.Statements.Add(
new CodeConditionStatement(
notNullCondition,
new CodeStatement[] { valueConstructor, },
new CodeStatement[] { nullConstructor, }
)
);
return(variableReference);
}
/// <summary>
/// Create a method entry point for a function import yielding an entity reader.
/// </summary>
/// <param name="functionImport">SOM for function import; must not be null and must yield
/// an entity reader.</param>
/// <returns>Method definition.</returns>
private CodeMemberMethod CreateFunctionImportStructuralTypeReaderMethod(EdmFunction functionImport)
{
// Trying to get:
//
///// <summary>
///// Documentation
///// </summary>
//public ObjectQueryResult<MyType> MyFunctionImport(Nullable<int> id, string foo)
//{
// ObjectParameter idParameter;
// if (id.HasValue)
// {
// idParameter = new ObjectParameter("id", id);
// }
// else
// {
// idParameter = new ObjectParameter("id", typeof(int));
// }
// ObjectParameter fooParameter;
// if (null != foo)
// {
// fooParameter = new ObjectParameter("foo", foo);
// }
// else
// {
// fooParameter = new ObjectParameter("foo", typeof(string));
// }
// return base.ExecuteFunction<MyType>("MyFunctionImport", idParameter, fooParameter);
//}
Debug.Assert(null != functionImport);
CodeMemberMethod method = new CodeMemberMethod();
Generator.AttributeEmitter.EmitGeneratedCodeAttribute(method);
method.Name = functionImport.Name;
method.Attributes = GetFunctionImportAccessibility(functionImport) | MemberAttributes.Final;
UniqueIdentifierService uniqueIdentifierService = new UniqueIdentifierService(
this.Generator.IsLanguageCaseSensitive,
s => Utils.FixParameterName(s));
// determine element return type
EdmType returnType = GetReturnTypeFromFunctionImport(functionImport);
if (Helper.IsCollectionType(returnType))
{
// get the type in the collection
returnType = ((CollectionType)returnType).TypeUsage.EdmType;
}
CodeTypeReference elementType = Generator.GetLeastPossibleQualifiedTypeReference(returnType);
method.ReturnType = TypeReference.ObjectResult(elementType);
// generate <summary> comments based on CSDL Documentation element
CommentEmitter.EmitSummaryComments(functionImport, method.Comments);
// build up list of arguments to ExecuteFunction
List <CodeExpression> executeArguments = new List <CodeExpression>();
executeArguments.Add(new CodePrimitiveExpression(functionImport.Name)); // first argument is the name of the function
foreach (FunctionParameter parameter in functionImport.Parameters)
{
CreateFunctionArgument(method, uniqueIdentifierService, parameter);
}
// add fields representing object parameters
foreach (FunctionParameter parameter in functionImport.Parameters)
{
if (parameter.Mode == ParameterMode.In)
{
CodeExpression variableReference = CreateFunctionParameter(method, uniqueIdentifierService, parameter);
executeArguments.Add(variableReference);
}
else
{
// the parameter is already being passed in as an argument; just remember it and
// pass it in as an argument
string adjustedParameterName;
if (!uniqueIdentifierService.TryGetAdjustedName(parameter, out adjustedParameterName))
{
Debug.Fail("parameter must be registered in identifier service");
}
executeArguments.Add(new CodeVariableReferenceExpression(adjustedParameterName));
}
}
// Add call to ExecuteFunction
// return ExecuteFunction<elementType>("FunctionImportName", { object parameters });
CodeMethodReferenceExpression executeFunctionMethod = new CodeMethodReferenceExpression(
new CodeBaseReferenceExpression(),
"ExecuteFunction",
new CodeTypeReference[] { elementType });
method.Statements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(executeFunctionMethod, executeArguments.ToArray())
)
);
// invoke the ExecuteFunction method passing in parameters
return(method);
}
/// <summary>
/// Emit static factory method which creates an instance of the class and initializes
/// non-nullable properties (taken as arguments)
/// </summary>
/// <param name="typeDecl"></param>
protected virtual void EmitFactoryMethod(CodeTypeDeclaration typeDecl)
{
// build list of non-nullable properties
ReadOnlyMetadataCollection <EdmProperty> properties = GetProperties();
List <EdmProperty> parameters = new List <EdmProperty>(properties.Count);
foreach (EdmProperty property in properties)
{
bool include = IncludeFieldInFactoryMethod(property);
if (include)
{
parameters.Add(property);
}
}
// if there are no parameters, we don't emit anything (1 is for the null element)
// nor do we emit everything if this is the Ref propertied ctor and the parameter list is the same as the many parametered ctor
if (parameters.Count < 1)
{
return;
}
CodeMemberMethod method = new CodeMemberMethod();
CodeTypeReference typeRef = TypeReference.FromString(Item.Name);
UniqueIdentifierService uniqueIdentifierService = new UniqueIdentifierService(Generator.IsLanguageCaseSensitive);
string instanceName = uniqueIdentifierService.AdjustIdentifier(Utils.CamelCase(Item.Name));
// public static Class CreateClass(...)
method.Attributes = MemberAttributes.Static | MemberAttributes.Public;
method.Name = "Create" + Item.Name;
if (NavigationPropertyEmitter.IsNameAlreadyAMemberName(Item, method.Name, Generator.LanguageAppropriateStringComparer))
{
Generator.AddError(Strings.GeneratedFactoryMethodNameConflict(method.Name, Item.Name),
ModelBuilderErrorCode.GeneratedFactoryMethodNameConflict,
EdmSchemaErrorSeverity.Error);
}
method.ReturnType = typeRef;
AttributeEmitter.AddGeneratedCodeAttribute(method);
// output method summary comments
CommentEmitter.EmitSummaryComments(Strings.FactoryMethodSummaryComment(Item.Name), method.Comments);
// Class class = new Class();
CodeVariableDeclarationStatement createNewInstance = new CodeVariableDeclarationStatement(
typeRef, instanceName, new CodeObjectCreateExpression(typeRef));
method.Statements.Add(createNewInstance);
CodeVariableReferenceExpression instanceRef = new CodeVariableReferenceExpression(instanceName);
// iterate over the properties figuring out which need included in the factory method
foreach (EdmProperty property in parameters)
{
// CreateClass( ... , propType propName ...)
PropertyEmitter propertyEmitter = new PropertyEmitter(Generator, property, UsingStandardBaseClass);
CodeTypeReference propertyTypeReference = propertyEmitter.PropertyType;
String parameterName = uniqueIdentifierService.AdjustIdentifier(Utils.FixParameterName(propertyEmitter.PropertyName, "argument"));
parameterName = Utils.SetSpecialCaseForFxCopOnPropertyName(parameterName);
CodeParameterDeclarationExpression paramDecl = new CodeParameterDeclarationExpression(
propertyTypeReference, parameterName);
CodeArgumentReferenceExpression paramRef = new CodeArgumentReferenceExpression(paramDecl.Name);
method.Parameters.Add(paramDecl);
// add comment describing the parameter
CommentEmitter.EmitParamComments(paramDecl, Strings.FactoryParamCommentGeneral(propertyEmitter.PropertyName), method.Comments);
CodeExpression newPropertyValue;
if (TypeSemantics.IsComplexType(propertyEmitter.Item.TypeUsage))
{
List <CodeExpression> complexVerifyParameters = new List <CodeExpression>();
complexVerifyParameters.Add(paramRef);
complexVerifyParameters.Add(new CodePrimitiveExpression(propertyEmitter.PropertyName));
// if (null == param) { throw new ArgumentNullException("PropertyName"); }
method.Statements.Add(
new CodeConditionStatement(
EmitExpressionEqualsNull(paramRef),
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
TypeReference.ForType(typeof(ArgumentNullException)),
new CodePrimitiveExpression(parameterName)
)
)
)
);
newPropertyValue = paramRef;
}
else
{
newPropertyValue = paramRef;
}
// Scalar property:
// Property = param;
// Complex property:
// Property = StructuralObject.VerifyComplexObjectIsNotNull(param, propertyName);
method.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(instanceRef, propertyEmitter.PropertyName), newPropertyValue));
}
// return class;
method.Statements.Add(new CodeMethodReturnStatement(instanceRef));
// actually add the method to the class
typeDecl.Members.Add(method);
}