public TestHookCommandInvocationData TestHookGetInvocationData()
{
object[] objArray = new object[2];
objArray[0] = "GetInvocationData";
objArray[1] = "EntityUpdate";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public bool AddArrayFieldParameter(string parameter, IEnumerable <object> values)
{
object[] objArray = new object[2];
objArray[0] = "AddArrayFieldParameter";
objArray[1] = "PipelineInvocation";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public void VerifyConcurrencyValues(IEnumerable <KeyValuePair <string, object> > values)
{
object[] objArray = new object[2];
objArray[0] = "VerifyConcurrencyValues";
objArray[1] = "EntityUpdate";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public static void AddParametersToCommand(ICommand command, Uri uri)
{
try
{
NameValueCollection nameValueCollection = HttpUtility.ParseQueryString(uri.Query);
foreach (string key in nameValueCollection.Keys)
{
if (key == null || string.IsNullOrWhiteSpace(key))
{
object[] str = new object[1];
str[0] = uri.ToString();
throw new DataServiceException(0x190, ExceptionHelpers.GetDataServiceExceptionMessage(HttpStatusCode.BadRequest, Resources.InvalidQueryParameterMessage, str));
}
else
{
string[] values = nameValueCollection.GetValues(key);
if ((int)values.Length == 1)
{
string str1 = values[0];
if (!string.IsNullOrWhiteSpace(str1))
{
string str2 = key.Trim();
if (str2.StartsWith("$", StringComparison.OrdinalIgnoreCase))
{
continue;
}
try
{
command.AddParameter(str2, str1.Trim(), true);
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
object[] objArray = new object[1];
objArray[0] = uri.ToString();
throw new DataServiceException(0x190, string.Empty, ExceptionHelpers.GetDataServiceExceptionMessage(HttpStatusCode.BadRequest, Resources.InvalidQueryParameterMessage, objArray), string.Empty, argumentException);
}
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = uri.ToString();
throw new DataServiceException(0x190, ExceptionHelpers.GetExceptionMessage(Resources.InvalidQueryParameterMessage, objArray1));
}
}
else
{
object[] objArray2 = new object[1];
objArray2[0] = uri.ToString();
throw new DataServiceException(0x190, ExceptionHelpers.GetDataServiceExceptionMessage(HttpStatusCode.BadRequest, Resources.InvalidQueryParameterMessage, objArray2));
}
}
}
}
catch (Exception exception)
{
TraceHelper.Current.UriParsingFailed(uri.ToString());
throw;
}
}
internal ResourceSet AddResourceSet(string name, ResourceType entityType)
{
name.ThrowIfNullOrEmpty("name", Resources.NullIsPassedAsResourceSetName, new object[0]);
object[] objArray = new object[1];
objArray[0] = name;
entityType.ThrowIfNull("entityType", Resources.ParameterSetNull, objArray);
if (entityType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
ResourceSet resourceSet = new ResourceSet(name, entityType);
if (!this.ResourceSets.Keys.Contains <string>(name))
{
this.ResourceSets.Add(name, resourceSet);
return(resourceSet);
}
else
{
object[] item = new object[3];
item[0] = name;
item[1] = entityType.Name;
item[2] = this.ResourceSets[name];
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.ResourceSetNameDuplicated, item));
}
}
else
{
throw new InvalidResourceTypeException(entityType.Name, entityType.ResourceTypeKind.ToString(), ResourceTypeKind.EntityType.ToString());
}
}
private ulong GetCommonParameterSets(string parameter)
{
ulong num = this.cmdletInfo.FindParameterSets(parameter);
object[] cmdletName = new object[2];
cmdletName[0] = parameter;
cmdletName[1] = this.cmdletInfo.CmdletName;
ExceptionHelpers.ThrowArgumentExceptionIf("parameter", num == (long)0, Resources.ParameterNotFoundInCommand, cmdletName);
if (this.parameters.Count > 0)
{
ulong num1 = this.commonParameterFlag & num;
if (num1 != (long)0)
{
num = num1;
}
else
{
object[] objArray = new object[2];
objArray[0] = parameter;
objArray[1] = this.cmdletInfo.CmdletName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.ParametersAddedFromExclusiveSets, objArray));
}
}
return(num);
}
public override object Serialize(object clrObject, int depth)
{
CollectionResourceType resourceType = base.ResourceType as CollectionResourceType;
if (clrObject as PSObject != null)
{
clrObject = (clrObject as PSObject).BaseObject;
}
if (clrObject != null)
{
Type type = clrObject.GetType();
if (!TypeSystem.ContainsDictionaryInterface(type))
{
if (!TypeSystem.ContainsEnumerableInterface(type))
{
object[] assemblyQualifiedName = new object[1];
assemblyQualifiedName[0] = type.AssemblyQualifiedName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.CollectionSeralizationFailedNotValidCollectionType, assemblyQualifiedName));
}
else
{
return(this.SerializeEnumerable(clrObject as IEnumerable, resourceType, depth));
}
}
else
{
return(this.SerializeDictionary(clrObject as IDictionary, resourceType, depth));
}
}
else
{
return(this.SerializeEnumerable(null, resourceType, depth));
}
}
public static object Build(Type type, Dictionary <string, object> properties)
{
object obj = TypeSystem.CreateInstance(type);
foreach (string key in properties.Keys)
{
object item = properties[key];
PropertyInfo settablePropertyInfo = TypeSystem.GetSettablePropertyInfo(type, key);
if (settablePropertyInfo == null)
{
FieldInfo fieldInfoFromPropertyName = TypeSystem.GetFieldInfoFromPropertyName(type, key);
if (fieldInfoFromPropertyName != null)
{
item = TypeSystem.ConvertEnumerableToCollection(item, fieldInfoFromPropertyName.FieldType);
fieldInfoFromPropertyName.SetValue(obj, item);
}
else
{
object[] assemblyQualifiedName = new object[2];
assemblyQualifiedName[0] = key;
assemblyQualifiedName[1] = type.AssemblyQualifiedName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.SettablePropertyNotFound, assemblyQualifiedName), "instance");
}
}
else
{
item = TypeSystem.ConvertEnumerableToCollection(item, settablePropertyInfo.PropertyType);
settablePropertyInfo.SetValue(obj, item, null);
}
}
return(obj);
}
public static SchemaLoader.ClassCategory GetCategory(this ClassDeclaration classDecl)
{
bool qualifier = classDecl.GetQualifier("ComplexType") != null;
bool flag = classDecl.GetQualifier("Association") != null;
if (!qualifier || !flag)
{
if (!qualifier)
{
if (!flag)
{
return(SchemaLoader.ClassCategory.Entity);
}
else
{
return(SchemaLoader.ClassCategory.Association);
}
}
else
{
return(SchemaLoader.ClassCategory.Complex);
}
}
else
{
object[] fullName = new object[1];
fullName[0] = classDecl.Name.FullName;
throw new MetadataException(ExceptionHelpers.GetExceptionMessage(Resources.ComplexTypeWithAssociation, fullName));
}
}
public object Resolve()
{
if (this.factory == null)
{
ResourceCustomState customState = this.resourceType.CustomState as ResourceCustomState;
if (customState != null)
{
foreach (string list in this.properties.Keys.ToList <string>())
{
object item = this.properties[list];
item = EntityUpdate.ResolveUpdatableObject(item);
item = EntityUpdate.ResolveUpdatableObjectList(item);
this.properties[list] = item;
}
return(ComplexTypeInstance.ClrInstanceForComplexTypeBuilder.Build(customState.ClrType, this.properties));
}
else
{
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(Resources.ResourceCustomStateNull, new object[0]));
}
}
else
{
return(this.factory(this.properties));
}
}
public IEnumerator <DSResource> InvokeAsync(Expression expression, bool noStreamingResponse)
{
object[] objArray = new object[2];
objArray[0] = "Invoke";
objArray[1] = "EntityUpdate";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public bool IsAuthorized(UserContext userContext, Uri resourceUri)
{
SenderInfo senderInfo = new SenderInfo(userContext.GetIdentity(), userContext.ClientCertificate, resourceUri);
CustomAuthorizationHandler.CustomContext customContext = null;
TraceHelper.Current.MethodCall0("CustomAuthorizationHandler", "IsAuthorized");
try
{
using (OperationTracerWithTimeout operationTracerWithTimeout = new OperationTracerWithTimeout(new Action <string>(TraceHelper.Current.CustomAuthzCallStart), new Action <string>(TraceHelper.Current.CustomAuthzCallEnd), "AuthorizeUser", new Action <string>(TraceHelper.Current.CustomAuthzExceedTimeLimit), 30))
{
UserQuota userQuotum = null;
WindowsIdentity windowsIdentity = this.customAuthorization.AuthorizeUser(senderInfo, out userQuotum);
if (windowsIdentity != null)
{
if (userQuotum != null)
{
TraceHelper.Current.UserQuotaInformation(userContext.Name, userQuotum.MaxConcurrentRequests, userQuotum.MaxRequestsPerTimeSlot, userQuotum.TimeSlotSize);
customContext = new CustomAuthorizationHandler.CustomContext(windowsIdentity, userQuotum);
}
else
{
object[] nullQuota = new object[2];
nullQuota[0] = "CustomAuthorization.AuthorizeUser";
nullQuota[1] = Resources.NullQuota;
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(Resources.MethodReturnedInvalidOutput, nullQuota));
}
}
else
{
object[] nullWindowsIdentity = new object[2];
nullWindowsIdentity[0] = "CustomAuthorization.AuthorizeUser";
nullWindowsIdentity[1] = Resources.NullWindowsIdentity;
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(Resources.MethodReturnedInvalidOutput, nullWindowsIdentity));
}
}
}
catch (Exception exception1)
{
Exception exception = exception1;
if (!exception.IsSevereException())
{
exception.Trace(null);
}
else
{
throw;
}
}
this.customContextStore.StoreContext(customContext);
if (customContext == null || customContext.Identity == null)
{
TraceHelper.Current.AuthorizeUserRequestFailed(userContext.Name, userContext.AuthenticationType);
return(false);
}
else
{
TraceHelper.Current.AuthorizeUserRequestSucceeded(userContext.Name);
return(true);
}
}
public void VerifyConcurrencyValues(IEnumerable <KeyValuePair <string, object> > values)
{
DSResource originalResource = this.GetOriginalResource();
if (originalResource != null)
{
foreach (KeyValuePair <string, object> value in values)
{
object obj = originalResource.GetValue(value.Key, null);
if (obj.Equals(value.Value))
{
continue;
}
object[] key = new object[2];
key[0] = value.Key;
key[1] = value.Value;
throw new DataServiceException(0x19c, ExceptionHelpers.GetDataServiceExceptionMessage(HttpStatusCode.PreconditionFailed, Resources.PropertyKey, key));
}
return;
}
else
{
throw new OptimisticConcurrencyException(ExceptionHelpers.GetExceptionMessage(Resources.GetCmdletNotReturningAnObject, new object[0]));
}
}
public void AddParameter(string parameter, object value, bool isOption)
{
object[] objArray = new object[2];
objArray[0] = "AddParameter";
objArray[1] = "EntityUpdate";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public override object Serialize(object clrObject, int depth)
{
if (clrObject == null)
{
clrObject = this.defaultValue;
}
else
{
if (clrObject.GetType() != base.ResourceType.InstanceType)
{
try
{
clrObject = TypeConverter.ConvertTo(clrObject, base.ResourceType.InstanceType);
}
catch (InvalidCastException invalidCastException1)
{
InvalidCastException invalidCastException = invalidCastException1;
object[] message = new object[2];
message[0] = this.name;
message[1] = invalidCastException.Message;
throw new DataServiceException(ExceptionHelpers.GetExceptionMessage(invalidCastException, Resources.PropertyNotSerialized, message), invalidCastException);
}
}
}
return(clrObject);
}
public static PropertyDeclaration GetProperty(this ClassDeclaration classDecl, string propertyName, HashSet <MofProduction> mof)
{
Func <PropertyDeclaration, bool> func = null;
Func <MofProduction, bool> func1 = null;
while (true)
{
NodeList <PropertyDeclaration> properties = classDecl.Properties;
if (func == null)
{
func = (PropertyDeclaration it) => string.Equals(it.Name, propertyName, StringComparison.Ordinal);
}
PropertyDeclaration propertyDeclaration = properties.FirstOrDefault <PropertyDeclaration>(func);
if (propertyDeclaration != null)
{
return(propertyDeclaration);
}
if (classDecl.SuperclassName == null)
{
break;
}
HashSet <MofProduction> mofProductions = mof;
if (func1 == null)
{
func1 = (MofProduction item) => item.GetFullClassName() == classDecl.SuperclassName.FullName;
}
classDecl = mofProductions.First <MofProduction>(func1) as ClassDeclaration;
}
object[] fullClassName = new object[2];
fullClassName[0] = propertyName;
fullClassName[1] = classDecl.GetFullClassName();
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.PropertyNotFoundInODataResource, fullClassName));
}
private bool ValidateParameterForSwitch(string parameter, object value)
{
if (!this.cmdletInfo.IsSwitch(parameter))
{
return(true);
}
else
{
bool flag = false;
try
{
flag = (bool)TypeConverter.ConvertTo(value, typeof(bool));
}
catch (InvalidCastException invalidCastException1)
{
InvalidCastException invalidCastException = invalidCastException1;
object[] cmdletName = new object[2];
cmdletName[0] = parameter;
cmdletName[1] = this.cmdletInfo.CmdletName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(invalidCastException, Resources.NotValidUrlOption, cmdletName), invalidCastException);
}
if (!flag)
{
TraceHelper.Current.DebugMessage(string.Concat("Switch parameter ", parameter, " with false value is passed. So not adding that in the PowerShell pipeline"));
}
return(flag);
}
}
public void Reset()
{
object[] objArray = new object[2];
objArray[0] = "Reset";
objArray[1] = "EntityUpdate";
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.NotImplementedExceptionMessage, objArray));
}
public IEnumerator <DSResource> InvokeAsync(Expression expression, bool noStreamingResponse)
{
IEnumerator <DSResource> enumerator;
using (OperationTracer operationTracer = new OperationTracer("Entering Pipeline.InvokeAsync"))
{
MonitorLock monitorLock = new MonitorLock(this);
MonitorLock monitorLock1 = monitorLock;
using (monitorLock)
{
if (this.Command == null || this.OutputFormat == null)
{
throw new DataServiceException(ExceptionHelpers.GetExceptionMessage(Resources.InvalidInvocationData, new object[0]));
}
else
{
this.ExpirationTime = DateTimeHelper.UtcNow;
DateTime expirationTime = this.ExpirationTime;
this.ExpirationTime = expirationTime.AddMilliseconds((double)this.WaitMsec);
DateTime dateTime = this.ExpirationTime;
this.ExpirationTime = dateTime.AddSeconds((double)DataServiceController.Current.Configuration.Invocation.Lifetime);
WindowsImpersonationContext windowsImpersonationContext = this.executionToken.Instance.Impersonate();
using (windowsImpersonationContext)
{
using (OperationTracer operationTracer1 = new OperationTracer("PowerShell.Create"))
{
ScriptBlockAst scriptBlockAst = this.ValidateAndBuildPipeline(string.Concat(this.Command, "| ConvertTo-", this.OutputFormat));
Runspace.DefaultRunspace = this.runspace.Item.Runspace;
this.powerShell = scriptBlockAst.GetScriptBlock().GetPowerShell(new object[0]);
this.powerShell.Runspace = this.runspace.Item.Runspace;
Runspace.DefaultRunspace = null;
}
TraceHelper.Current.BeginOperation0("RunspaceContext.Create");
DefaultRunspaceContext defaultRunspaceContext = DefaultRunspaceContext.Create(this.runspace.Item.Runspace);
using (defaultRunspaceContext)
{
TraceHelper.Current.EndOperation("RunspaceContext.Create");
TraceHelper.Current.PipelineStart(this.ID, this.Command, this.OutputFormat);
this.outputObjects.DataAdded += new EventHandler <DataAddedEventArgs>(this.DataAddedEventHandler);
this.powerShell.BeginInvoke <PSObject, PSObject>(null, this.outputObjects, Utils.GetPSInvocationSettings(), this.TestHookCompletionCallback, null);
monitorLock1.Exit();
this.finished.WaitOne(this.WaitMsec);
this.timer.Start();
monitorLock1.Enter();
List <DSResource> dSResources = new List <DSResource>();
dSResources.Add(this.MakeDsResource());
TraceHelper.Current.DebugMessage("Exiting Pipeline.InvokeAsync");
enumerator = dSResources.AsEnumerable <DSResource>().GetEnumerator();
}
}
}
}
}
return(enumerator);
}
public void AddEnds(Schema.AssociationEnd end1, Schema.AssociationEnd end2)
{
if (this.Ends.Count == 0)
{
this.Ends.Add(end1);
this.Ends.Add(end2);
return;
}
else
{
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.AssociationMoreThanTwoEndNotSupported, new object[0]));
}
}
public void ValidateResourceLimits(DSConfiguration configuration)
{
foreach (DSConfiguration.WcfConfigElement entitySet in configuration.DataServicesConfig.EntitySets)
{
if (!(entitySet.Name != "*") || this.ResourceSets.ContainsKey(entitySet.Name))
{
continue;
}
object[] name = new object[1];
name[0] = entitySet.Name;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.ConfigurationHasInvalidEntitySet, name));
}
}
public IIdentity GetIdentity()
{
IIdentity identity = CurrentRequestHelper.Identity;
if (!string.Equals(this.Name, identity.Name, StringComparison.OrdinalIgnoreCase) || !string.Equals(this.AuthenticationType, identity.AuthenticationType, StringComparison.OrdinalIgnoreCase))
{
object[] traceMessage = new object[2];
traceMessage[0] = this.ToTraceMessage("User Context");
traceMessage[1] = identity.ToTraceMessage();
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(Resources.UserNameContextIdentityMismatch, traceMessage));
}
else
{
return(CurrentRequestHelper.Identity);
}
}
public void RequestProcessed()
{
TraceHelper.Current.DebugMessage(string.Concat("Usage.RequestProcessed called. Concurrent requests = ", this.concurrentRequests));
lock (this.syncObject)
{
if (this.concurrentRequests != 0)
{
Usage usage = this;
usage.concurrentRequests = usage.concurrentRequests - 1;
}
else
{
throw new OverflowException(ExceptionHelpers.GetExceptionMessage(Resources.ConcurrentRequestZero, new object[0]));
}
}
}
public static WellKnownTypeFactory GetFactory(string typeName)
{
WellKnownTypeFactory wellKnownTypeFactory = null;
WellKnownTypes.typeFactoryMap.TryGetValue(typeName, out wellKnownTypeFactory);
if (wellKnownTypeFactory == null)
{
object[] objArray = new object[1];
objArray[0] = typeName;
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.ComplexTypeNotSupported, objArray));
}
else
{
return(wellKnownTypeFactory);
}
}
public InitialSessionState Create(UserContext userContext, string membershipId)
{
InitialSessionState initialSessionState;
using (OperationTracerWithTimeout operationTracerWithTimeout = new OperationTracerWithTimeout(new Action <string>(TraceHelper.Current.PSSessionCallStart), new Action <string>(TraceHelper.Current.PSSessionCallEnd), "InitialSessionState", new Action <string>(TraceHelper.Current.PSSessionMethodExceededTimeLimit), 30))
{
PSCertificateDetails pSCertificateDetail = null;
if (userContext.ClientCertificate != null)
{
pSCertificateDetail = new PSCertificateDetails(userContext.ClientCertificate.Subject, userContext.ClientCertificate.Issuer, userContext.ClientCertificate.Thumbprint);
}
PSIdentity pSIdentity = new PSIdentity(userContext.AuthenticationType, userContext.IsAuthenticated, userContext.Name, pSCertificateDetail);
PSPrincipal pSPrincipal = new PSPrincipal(pSIdentity, userContext.GetIdentity() as WindowsIdentity);
PSSenderInfo pSSenderInfo = new PSSenderInfo(pSPrincipal, DataServiceController.Current.GetCurrentResourceUri().ToString());
try
{
InitialSessionState initialSessionState1 = this.sessionConfiguration.GetInitialSessionState(pSSenderInfo);
if (initialSessionState1 != null)
{
TraceHelper.Current.GetInitialSessionStateRequestSucceeded(userContext.Name);
initialSessionState1.Trace();
initialSessionState = initialSessionState1;
}
else
{
object[] objArray = new object[2];
objArray[0] = "PSSessionState.GetInitialSessionState";
objArray[1] = "null";
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(Resources.MethodReturnedInvalidOutput, objArray));
}
}
catch (Exception exception1)
{
Exception exception = exception1;
TraceHelper.Current.GetInitialSessionStateRequestFailed(userContext.Name, exception.Message);
if (!exception.IsSevereException())
{
throw new CustomModuleInvocationFailedException(this.sessionConfiguration.GetType().AssemblyQualifiedName, "GetInitialState", exception);
}
else
{
throw;
}
}
}
return(initialSessionState);
}
public object CreateResource(string containerName, string fullTypeName)
{
TraceHelper.Current.MethodCall2("DataServiceUpdateProvider", "AddReferenceToCollection", containerName, fullTypeName);
ResourceType resourceType = null;
if (containerName != null)
{
ResourceSet resourceSet = null;
this.dataContext.UserSchema.ResourceSets.TryGetValue(containerName, out resourceSet);
object[] objArray = new object[1];
objArray[0] = containerName;
ExceptionHelpers.ThrowArgumentExceptionIf("set", resourceSet == null, Resources.MissingResourceSet, objArray);
if (this.entityInstance == null)
{
resourceType = resourceSet.ResourceType;
EntityMetadata item = this.dataContext.UserSchema.EntityMetadataDictionary[resourceSet.ResourceType.FullName];
this.entityInstance = new EntityUpdate(this.dataContext.UserContext, resourceType, item, this.dataContext.MembershipId);
this.instances.Add(this.entityInstance);
return(this.entityInstance);
}
else
{
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.BatchUpdatesNotSupported, new object[0]));
}
}
else
{
this.dataContext.UserSchema.ResourceTypes.TryGetValue(fullTypeName, out resourceType);
if (resourceType != null)
{
object[] objArray1 = new object[1];
objArray1[0] = fullTypeName;
ExceptionHelpers.ThrowArgumentExceptionIf("fullTypeName", resourceType.ResourceTypeKind != ResourceTypeKind.ComplexType, Resources.NotAComplexType, objArray1);
IUpdateInstance complexTypeInstance = new ComplexTypeInstance(resourceType);
this.instances.Add(complexTypeInstance);
return(complexTypeInstance);
}
else
{
TraceHelper.Current.ResourceTypeNotFound(fullTypeName);
object[] objArray2 = new object[1];
objArray2[0] = fullTypeName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.MissingResourceType, objArray2));
}
}
}
public PSRunspace(InitialSessionState initialSessionState, bool executeCmdletInSameThread = false)
{
try
{
this.Runspace = RunspaceFactory.CreateRunspace(initialSessionState);
if (executeCmdletInSameThread)
{
this.Runspace.ThreadOptions = PSThreadOptions.UseCurrentThread;
}
this.Runspace.Open();
DataServiceController.Current.PerfCounters.ActiveRunspaces.Increment();
}
catch (Exception exception1)
{
Exception exception = exception1;
TraceHelper.Current.FailedToCreateRunspace(exception.ToTraceMessage("Exception"));
throw new InvalidOperationException(ExceptionHelpers.GetExceptionMessage(exception, Resources.PowerShellConstrainedRunspaceCreationFailed, new object[0]), exception);
}
}
public static object GetFieldValue(object instance, string propertyName)
{
object value;
Type type = instance.GetType();
FieldInfo fieldInfoFromPropertyName = TypeSystem.GetFieldInfoFromPropertyName(type, propertyName);
if (fieldInfoFromPropertyName != null)
{
try
{
value = fieldInfoFromPropertyName.GetValue(instance);
}
catch (Exception exception1)
{
Exception exception = exception1;
TraceHelper.Current.DebugMessage(exception.ToTraceMessage(string.Concat("GetFieldValue failed to parse property: ", propertyName)));
if (!exception.IsIgnorablePropertyException())
{
if (!exception.IsSevereException())
{
object[] message = new object[2];
message[0] = propertyName;
message[1] = exception.Message;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.PropertyRetrievalFailed, message), exception);
}
else
{
throw;
}
}
else
{
value = null;
}
}
return(value);
}
else
{
return(null);
}
}
internal void AddPrimitiveProperty(ResourceType resourceType, string name, Type propertyType, ResourcePropertyKind flags, object defaultValue)
{
if (flags == ResourcePropertyKind.Primitive || flags == (ResourcePropertyKind.Primitive | ResourcePropertyKind.ETag) || flags == (ResourcePropertyKind.Primitive | ResourcePropertyKind.Key))
{
ResourceType primitiveResourceType = ResourceType.GetPrimitiveResourceType(propertyType);
ResourcePropertyKind resourcePropertyKind = ResourcePropertyKind.Primitive;
resourcePropertyKind = resourcePropertyKind | flags;
ResourceProperty resourcePropertyWithDescription = new ResourcePropertyWithDescription(name, resourcePropertyKind, primitiveResourceType);
resourcePropertyWithDescription.CanReflectOnInstanceTypeProperty = false;
PropertyCustomState propertyCustomState = new PropertyCustomState();
propertyCustomState.DefaultValue = defaultValue;
resourcePropertyWithDescription.CustomState = propertyCustomState;
resourceType.AddProperty(resourcePropertyWithDescription);
return;
}
else
{
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.SchemaInvalidKeyOrEtagDiscrepancy, new object[0]), "flags");
}
}
private IEnumerable <DSResource> GetUniqueKeys(IQueryable <DSResource> source, ResourceProperty property)
{
DSResource.KeyEqualityComparer keyEqualityComparer = new DSResource.KeyEqualityComparer();
List <DSResource> dSResources = new List <DSResource>();
foreach (DSResource dSResource in source)
{
if (property.Kind != ResourcePropertyKind.ResourceReference)
{
if (property.Kind != ResourcePropertyKind.ResourceSetReference)
{
throw new ArgumentException("the property is not a reference property", property.Name);
}
else
{
object value = dSResource.GetValue(property.Name, this.resultSets);
IEnumerable <DSResource> dSResources1 = value as IEnumerable <DSResource>;
if (dSResources1 == null)
{
object[] name = new object[1];
name[0] = property.Name;
throw new UnauthorizedAccessException(ExceptionHelpers.GetExceptionMessage(Resources.NoAccessToNavProperty, name));
}
else
{
dSResources.AddRange(dSResources1);
}
}
}
else
{
DSResource value1 = dSResource.GetValue(property.Name, this.resultSets) as DSResource;
if (value1 == null)
{
continue;
}
dSResources.Add(value1);
}
}
return(dSResources.Distinct <DSResource>(keyEqualityComparer));
}
