public override PSMemberInfo Copy()
{
PSProperty destiny = new PSProperty(base.name, this.adapter, this.baseObject, this.adapterData);
base.CloneBaseProperties(destiny);
destiny.typeOfValue = this.typeOfValue;
destiny.serializedValue = this.serializedValue;
destiny.isDeserialized = this.isDeserialized;
return destiny;
}
/// <summary>
/// Get the property signature.
/// </summary>
/// <param name="property">Property object whose signature we want.</param>
/// <returns>String representing the signature of the property.</returns>
protected override string PropertyToString(PSProperty property)
{
ComProperty prop = (ComProperty)property.adapterData;
return(prop.ToString());
}
/// <summary>
/// Returns true if the property is gettable.
/// </summary>
/// <param name="property">Property to check.</param>
/// <returns>True if the property is gettable.</returns>
protected override bool PropertyIsGettable(PSProperty property)
{
ComProperty prop = (ComProperty)property.adapterData;
return(prop.IsGettable);
}
/// <summary>
/// Returns the value from a property coming from a previous call to DoGetProperty.
/// </summary>
/// <param name="property">PSProperty coming from a previous call to DoGetProperty.</param>
/// <returns>The value of the property.</returns>
protected override object PropertyGet(PSProperty property)
{
ComProperty prop = (ComProperty)property.adapterData;
return(prop.GetValue(property.baseObject));
}
protected override bool PropertyIsSettable(PSProperty property)
{
ComProperty adapterData = (ComProperty)property.adapterData;
return(adapterData.IsSettable);
}
protected override bool PropertyIsGettable(PSProperty property) => true;
protected override string PropertyType(PSProperty property)
{
string adapterData = (string)property.adapterData;
return(((DataRow)property.baseObject).Table.Columns[adapterData].DataType.FullName);
}
/// <summary>
/// Sets the value of a property coming from a previous call to GetMember
/// </summary>
/// <param name="property">PSProperty coming from a previous call to GetMember</param>
/// <param name="setValue">value to set the property with</param>
/// <param name="convertIfPossible">instructs the adapter to convert before setting, if the adapter supports conversion</param>
protected override void PropertySet(PSProperty property, object setValue, bool convertIfPossible)
{
PropertyValueCollection values = property.adapterData as PropertyValueCollection;
if (null != values)
{
// This means GetMember returned PropertyValueCollection
try
{
values.Clear();
}
catch (System.Runtime.InteropServices.COMException e)
{
if (e.ErrorCode != unchecked ((int)0x80004005) || (setValue == null))
{
// When clear is called, DirectoryEntry calls PutEx on AD object with Clear option and Null Value
// WinNT provider throws E_FAIL when null value is specified though actually ADS_PROPERTY_CLEAR option is used,
// we need to catch this exception here.
// But at the same time we don't want to catch the exception if user explicitly sets the value to null.
throw;
}
}
IEnumerable enumValues = LanguagePrimitives.GetEnumerable(setValue);
if (enumValues == null)
{
values.Add(setValue);
}
else
{
foreach (object objValue in enumValues)
{
values.Add(objValue);
}
}
}
else
{
// This means GetMember returned the value from InvokeGet..So set the value using InvokeSet.
DirectoryEntry entry = (DirectoryEntry)property.baseObject;
Diagnostics.Assert(entry != null, "Object should be of type DirectoryEntry in DirectoryEntry adapter.");
List <object> setValues = new List <object>();
IEnumerable enumValues = LanguagePrimitives.GetEnumerable(setValue);
if (enumValues == null)
{
setValues.Add(setValue);
}
else
{
foreach (object objValue in enumValues)
{
setValues.Add(objValue);
}
}
entry.InvokeSet(property.name, setValues.ToArray());
}
return;
}
protected override void PropertySet(PSProperty property, object setValue, bool convertIfPossible)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override bool PropertyIsSettable(PSProperty property)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override object PropertyGet(PSProperty property)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override AttributeCollection PropertyAttributes(PSProperty property)
{
return new AttributeCollection(new Attribute[0]);
}
protected override object PropertyGet(PSProperty property) => property.adapterData;
protected override AttributeCollection PropertyAttributes(PSProperty property) => base.PropertyAttributes(property);
protected override string PropertyToString(PSProperty property) => base.PropertyToString(property);
/// <summary>
/// Returns true if the property is gettable
/// </summary>
/// <param name="property">property to check</param>
/// <returns>true if the property is gettable</returns>
protected override bool PropertyIsGettable(PSProperty property)
{
return(true);
}
/// <summary>
/// Returns null if memberName is not a member in the adapter or
/// the corresponding PSMemberInfo
/// </summary>
/// <param name="obj">object to retrieve the PSMemberInfo from</param>
/// <param name="memberName">name of the member to be retrieved</param>
/// <returns>The PSMemberInfo corresponding to memberName from obj</returns>
protected override T GetMember <T>(object obj, string memberName)
{
PSProperty property;
DirectoryEntry entry = (DirectoryEntry)obj;
// This line must precede InvokeGet. See the comment below.
PropertyValueCollection collection = entry.Properties[memberName];
object valueToTake = collection;
#pragma warning disable 56500
// Even for the cases where propertyName does not exist
// entry.Properties[propertyName] still returns a PropertyValueCollection.
// The non schema way to check for a non existing property is to call entry.InvokeGet
// and catch an eventual exception.
// Specifically for "LDAP://RootDse" there are some cases where calling
// InvokeGet will throw COMException for existing properties like defaultNamingContext.
// Having a call to entry.Properties[propertyName] fixes the RootDse problem.
// Calling entry.RefreshCache() also fixes the RootDse problem.
try
{
object invokeGetValue = entry.InvokeGet(memberName);
// if entry.Properties[memberName] returns empty value and invokeGet non-empty
// value..take invokeGet's value. This will fix bug Windows Bug 121188.
if ((null == collection) || ((null == collection.Value) && (null != invokeGetValue)))
{
valueToTake = invokeGetValue;
}
property = new PSProperty(collection.PropertyName, this, obj, valueToTake);
}
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
property = null;
}
#pragma warning restore 56500
if (valueToTake == null)
{
property = null;
}
if (typeof(T).IsAssignableFrom(typeof(PSProperty)) && property != null)
{
return(property as T);
}
if (typeof(T).IsAssignableFrom(typeof(PSMethod)))
{
if (property == null)
{
#region Readme
// we are unable to find a native adsi object property.
// The next option is to find method. Unfortunately DirectoryEntry
// doesn't provide us a way to access underlying native object's method
// metadata.
// Adapter engine resolve's members in the following steps:
// 1. Extended members -> 2. Adapted members -> 3. Dotnet members
// We cannot say from DirectoryEntryAdapter if a method with name "memberName"
// is available. So check if a DotNet property with the same name is available
// If yes, return null from the adapted view and let adapter engine
// take care of DotNet member resolution. If not, assume memberName method
// is available on native adsi object.
// In case of collisions between Dotnet Property and adsi native object methods,
// Dotnet wins. Looking through IADs com interfaces there doesn't appear
// to be a collision like this.
// Powershell Parser will call only GetMember<PSMemberInfo>, so here
// we cannot distinguish if the caller is looking for a property or a
// method.
#endregion
if (base.GetDotNetProperty <T>(obj, memberName) == null)
{
return(new PSMethod(memberName, this, obj, null) as T);
}
}
}
return(null);
}
protected override string PropertyToString(PSProperty property)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override string PropertyType(PSProperty property, bool forDisplay)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override string PropertyType(PSProperty property, bool forDisplay)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override bool PropertyIsSettable(PSProperty property)
{
string adapterData = (string)property.adapterData;
return(!((DataRow)property.baseObject).Table.Columns[adapterData].ReadOnly);
}
protected override void PropertySet(PSProperty property, object setValue, bool convertIfPossible)
{
DataRowView baseObject = (DataRowView)property.baseObject;
baseObject[(string)property.adapterData] = setValue;
}
protected override object PropertyGet(PSProperty property) => ((DataRow)property.baseObject)[(string)property.adapterData];
protected abstract object PropertyGet(PSProperty property);
/// <summary>
/// Returns an array with the property attributes.
/// </summary>
/// <param name="property">Property we want the attributes from.</param>
/// <returns>An array with the property attributes.</returns>
protected override AttributeCollection PropertyAttributes(PSProperty property)
{
return(new AttributeCollection());
}
protected abstract void PropertySet(
PSProperty property,
object setValue,
bool convertIfPossible);
/// <summary>
/// Sets the value of a property coming from a previous call to DoGetProperty.
/// </summary>
/// <param name="property">PSProperty coming from a previous call to DoGetProperty.</param>
/// <param name="setValue">Value to set the property with.</param>
/// <param name="convertIfPossible">instructs the adapter to convert before setting, if the adapter supports conversion</param>
protected override void PropertySet(PSProperty property, object setValue, bool convertIfPossible)
{
ComProperty prop = (ComProperty)property.adapterData;
prop.SetValue(property.baseObject, setValue);
}
protected abstract bool PropertyIsGettable(PSProperty property);
/// <summary>
/// Returns the name of the type corresponding to the property.
/// </summary>
/// <param name="property">PSProperty obtained in a previous DoGetProperty.</param>
/// <param name="forDisplay">True if the result is for display purposes only.</param>
/// <returns>The name of the type corresponding to the property.</returns>
protected override string PropertyType(PSProperty property, bool forDisplay)
{
ComProperty prop = (ComProperty)property.adapterData;
return(forDisplay ? ToStringCodeMethods.Type(prop.Type) : prop.Type.FullName);
}
protected abstract string PropertyType(PSProperty property);
private void CheckAndAddProperty(PSPropertyInfo propertyInfo, Attribute[] attributes, ref PropertyDescriptorCollection returnValue)
{
using (typeDescriptor.TraceScope("Checking property \"{0}\".", propertyInfo.Name))
{
// WriteOnly properties are not returned in TypeDescriptor.GetProperties, so we do the same.
if (!propertyInfo.IsGettable)
{
typeDescriptor.WriteLine("Property \"{0}\" is write-only so it has been skipped.", propertyInfo.Name);
return;
}
AttributeCollection propertyAttributes = null;
Type propertyType = typeof(object);
if (attributes != null && attributes.Length != 0)
{
PSProperty property = propertyInfo as PSProperty;
if (property != null)
{
DotNetAdapter.PropertyCacheEntry propertyEntry = property.adapterData as DotNetAdapter.PropertyCacheEntry;
if (propertyEntry is null)
{
typeDescriptor.WriteLine("Skipping attribute check for property \"{0}\" because it is an adapted property (not a .NET property).", property.Name);
}
else if (property.isDeserialized)
{
// At the moment we are not serializing attributes, so we can skip
// the attribute check if the property is deserialized.
typeDescriptor.WriteLine("Skipping attribute check for property \"{0}\" because it has been deserialized.", property.Name);
}
else
{
propertyType = propertyEntry.propertyType;
propertyAttributes = propertyEntry.Attributes;
foreach (Attribute attribute in attributes)
{
if (!propertyAttributes.Contains(attribute))
{
typeDescriptor.WriteLine("Property \"{0}\" does not contain attribute \"{1}\" so it has been skipped.", property.Name, attribute);
return;
}
}
}
}
}
if (propertyAttributes is null)
{
propertyAttributes = new AttributeCollection();
}
typeDescriptor.WriteLine("Adding property \"{0}\".", propertyInfo.Name);
PSObjectPropertyDescriptor propertyDescriptor =
new PSObjectPropertyDescriptor(propertyInfo.Name, propertyType, !propertyInfo.IsSettable, propertyAttributes);
propertyDescriptor.SettingValueException += this.SettingValueException;
propertyDescriptor.GettingValueException += this.GettingValueException;
returnValue.Add(propertyDescriptor);
}
}
protected abstract string PropertyToString(PSProperty property);
/// <summary>
/// Returns the value from a property coming from a previous call to DoGetProperty
/// </summary>
/// <param name="property">PSProperty coming from a previous call to DoGetProperty</param>
/// <returns>The value of the property</returns>
protected override object PropertyGet(PSProperty property)
{
DataRowView dataRowView = (DataRowView)property.baseObject;
return(dataRowView[(string)property.adapterData]);
}
protected abstract AttributeCollection PropertyAttributes(PSProperty property);
/// <summary>
/// Returns the value from a property coming from a previous call to GetMember
/// </summary>
/// <param name="property">PSProperty coming from a previous call to GetMember</param>
/// <returns>The value of the property</returns>
protected override object PropertyGet(PSProperty property)
{
return(property.adapterData);
}
/// <summary>
/// Returns the value from a property coming from a previous call to DoGetProperty
/// </summary>
/// <param name="property">PSProperty coming from a previous call to DoGetProperty</param>
/// <returns>The value of the property</returns>
protected override object PropertyGet(PSProperty property)
{
PropertyData pd = property.adapterData as PropertyData;
return(pd.Value);
}
private void ReadProperties(PSObject dso)
{
dso.isDeserialized = true;
dso.adaptedMembers = new PSMemberInfoInternalCollection<PSPropertyInfo>();
dso.clrMembers = new PSMemberInfoInternalCollection<PSPropertyInfo>();
if (this.ReadStartElementAndHandleEmpty("Props"))
{
while (this._reader.NodeType == XmlNodeType.Element)
{
string name = this.ReadNameAttribute();
object serializedValue = this.ReadOneObject();
PSProperty member = new PSProperty(name, serializedValue);
dso.adaptedMembers.Add(member);
}
this.ReadEndElement();
}
}
protected override string PropertyToString(PSProperty property)
{
throw PSTraceSource.NewNotSupportedException();
}
