public Member(StreamReader sr)
{
firstName = sr.ReadLine();
lastName = sr.ReadLine();
type = (MemberType)Convert.ToInt32(sr.ReadLine());
uiStudentNumber = Convert.ToUInt32(sr.ReadLine());
memberFaculty = (Faculty)Convert.ToInt32(sr.ReadLine());
otherInstrument = sr.ReadLine();
curInstrument = (Instrument)Convert.ToInt32(sr.ReadLine());
this.bMultipleInstruments = Convert.ToBoolean(sr.ReadLine());
// write if the member plays multiple instruments
// write any other instruments that the member plays (or does not play)
int numberOfInstruments = Enum.GetValues(typeof(Member.Instrument)).Length;
if (this.bMultipleInstruments)
{
playsInstrument = new bool[Enum.GetValues(typeof(Member.Instrument)).Length];
for (int j = 0; j < numberOfInstruments; j++)
playsInstrument[j] = Convert.ToBoolean(sr.ReadLine());
}
email = sr.ReadLine();
comments = ClsStorage.ReverseCleanNewLine(sr.ReadLine());
sID = Convert.ToInt16(sr.ReadLine());
signupTime = new DateTime(Convert.ToInt64(sr.ReadLine()));
size = (ShirtSize)Convert.ToInt32(sr.ReadLine());
}
public MemberMetadata(MemberInfo memberInfo)
{
_type = MemberType.None;
_memberType = null;
_mi = null;
_fp = null;
memberInfo.ThrowIfNull("memberInfo", "Parameter cannot be null.");
switch (memberInfo.MemberType)
{
case MemberTypes.Field:
_type = MemberType.Field;
_mi = memberInfo;
_memberType = (memberInfo as FieldInfo).FieldType;
break;
case MemberTypes.Property:
_type = MemberType.Property;
_memberType = (memberInfo as PropertyInfo).PropertyType;
_fp = new FastReflection.FastProperty((memberInfo as PropertyInfo), true);
_mi = memberInfo;
break;
default:
break;
}
}
private void LoadUc(MemberType usertype)
{
Control con = null;
//0 未设定 1 个人会员 2 家庭会员 3 学校会员 4 企业会员 ：
switch (usertype)
{
case MemberType.Initiation:
lblUserType.Text = "初始注册会员";
break;
case MemberType.Company:
lblUserType.Text = "企业会员";
con = (Control)Page.LoadControl("~/uc/UCCompanyMemberInfo.ascx");
break;
case MemberType.Famly:
lblUserType.Text = "家庭会员";
con = (Control)Page.LoadControl("~/uc/UCFamlyMemberInfo.ascx");
break;
case MemberType.Personal:
lblUserType.Text = "个人会员";
con = (Control)Page.LoadControl("~/uc/UCPersonMemberInfo.ascx");
break;
case MemberType.School:
lblUserType.Text = "学校会员";
con = (Control)Page.LoadControl("~/uc/UCSchoolMemberInfo.ascx");
break;
}
con.ID = "uccon";
phExtentInfo.Controls.Add(con);
}
public Member(Lumber lumberType, MemberType memberType, Polygon geometry, string name = "")
{
this.MemberType = memberType;
this.Lumber = lumberType;
this.Geometry = geometry;
this.Name = name;
}
public string Add(MemberType memtype)
{
try
{
if (memtype != null)
{
if (!IsDuplicate(string.Empty, memtype.MemberTypeName))
{
memtype.MemberTypeID = Guid.NewGuid().ToString();
memtype.DealerID = CommonConstant.GetFieldValueString(Session[CommonConstant.SessionUserID]);
memtype.UpdateDate = DateTime.Now;
memtype.CreateDate = DateTime.Now;
db.MemberTypes.Add(memtype);
db.SaveChanges();
return "Success";
}
else
{
return "This member type name already in used.";
}
}
}
catch(Exception ex)
{
LogFile.writeLogFile(DateTime.Now, "MemberTypeController", ex.ToString());
}
return "Add member type failed.";
}
public void SetPermissionFilters(int memberId, MemberType memberType, IEnumerable<PermissionFilter> permissionFilters)
{
if(permissionFilters == null)
throw new ArgumentNullException("permissionFilters");
this.SetPermissions(MembershipHelper.DATA_ENTITY_PERMISSION, memberId, memberType, permissionFilters);
}
public Member(
string firstName,
string lastName,
MemberType type,
uint uiStudentNumber,
int iFaculty,
string instrument,
string otherInstrument,
string email,
string comments,
int iShirt)
{
// declare basic information about user
this.firstName = firstName;
this.lastName = lastName;
this.type = type;
this.uiStudentNumber = uiStudentNumber;
this.memberFaculty = (Faculty)iFaculty;
this.curInstrument = ParseInstrument(instrument);
if (this.curInstrument == Instrument.Other && String.IsNullOrEmpty(otherInstrument))
this.otherInstrument = instrument;
else
this.otherInstrument = otherInstrument;
this.email = email;
this.comments = comments;
this.sID = ClsStorage.currentClub.iMember;
this.signupTime = DateTime.Now;
this.size = (ShirtSize)iShirt;
this.bMultipleInstruments = false;
}
public virtual void VisitMemberType(MemberType memberType)
{
/*if (this.ThrowException)
{
throw (Exception)this.CreateException(memberType);
}*/
}
public static TypeValueAccess Create(Type type, string name, MemberType memberType = MemberType.Instance | MemberType.Public | MemberType.Field | MemberType.Property)
{
//BindingFlags bindingFlags = BindingFlags.Instance;
//if ((memberType & pb.Reflection.MemberType.Public) == pb.Reflection.MemberType.Public)
// bindingFlags |= BindingFlags.Public;
//if ((memberType & pb.Reflection.MemberType.NonPublic) == pb.Reflection.MemberType.NonPublic)
// bindingFlags |= BindingFlags.NonPublic;
//foreach (MemberInfo member in type.GetMember(name, bindingFlags))
//{
// BindingFlags accessBindingFlag = 0;
// if (member.MemberType == MemberTypes.Field)
// accessBindingFlag = BindingFlags.GetField;
// else if (member.MemberType == MemberTypes.Property)
// accessBindingFlag = BindingFlags.GetProperty;
// //return new MemberAccess { SourceType = type, Name = member.Name, MemberTypes = member.MemberType, AccessBindingFlag = accessBindingFlag, MemberInfo = member };
// return new MemberAccess { SourceType = type, Name = member.Name, AccessBindingFlag = accessBindingFlag };
//}
//return null;
TypeValueInfo typeValueInfo = type.zGetTypeValueInfo(name, memberType);
if (typeValueInfo != null)
//return new MemberAccess { SourceType = type, Name = valueInfo.Name, AccessBindingFlag = GetAccessBindingFlag(valueInfo.MemberTypes) };
return new TypeValueAccess(typeValueInfo);
else
return null;
}
public static bool GetDefaultValueIfAny(MemberType memberType, MetadataReader reader, Handle constantHandle, Type declaredType, IEnumerable<CustomAttributeData> customAttributes, out Object defaultValue)
{
if (!(constantHandle.IsNull(reader)))
{
defaultValue = ParseMetadataConstant(reader, constantHandle);
if (declaredType.GetTypeInfo().IsEnum)
defaultValue = Enum.ToObject(declaredType, defaultValue);
return true;
}
if (memberType != MemberType.Property) // the attributes in question cannot be applied to properties.
{
// Legacy: If there are multiple default value attribute, the desktop picks one at random (and so do we...)
foreach (CustomAttributeData cad in customAttributes)
{
Type attributeType = cad.AttributeType;
TypeInfo attributeTypeInfo = attributeType.GetTypeInfo();
if (attributeTypeInfo.IsSubclassOf(typeof(CustomConstantAttribute)))
{
CustomConstantAttribute customConstantAttribute = (CustomConstantAttribute)(cad.Instantiate());
defaultValue = customConstantAttribute.Value;
return true;
}
if (attributeType.Equals(typeof(DecimalConstantAttribute)))
{
DecimalConstantAttribute decimalConstantAttribute = (DecimalConstantAttribute)(cad.Instantiate());
defaultValue = decimalConstantAttribute.Value;
return true;
}
}
}
defaultValue = null;
return false;
}
internal override void GenerateSyntax(MemberType type, ISymbol symbol, SyntaxDetail syntax, SymbolVisitorAdapter adapter)
{
foreach (var generator in _generators)
{
generator.GenerateSyntax(type, symbol, syntax, adapter);
}
}
private static string ConstantExpression(Expression exp, ref MemberType type, bool? isComparisonOperator)
{
type = MemberType.Value;
ConstantExpression ce = ((ConstantExpression)exp);
if (ce.Value == null)
return "null";
else if (ce.Value.ToString().IsIn("True", "False"))//是bool值
{
var ceType = ce.Value.GetType();
var ceValue = ce.Value.ToString();
if (isComparisonOperator==true)
{
var ceNewValue = ConstantBoolDictionary.Single(it => it.Type == ceType && it.OldValue.ToLower() == ceValue.ToLower());
return ceNewValue.NewValue;
}
else
{
var ceNewValue = ConstantBoolDictionary.Single(it => it.Type == ceType && it.OldValue.ToLower() == ceValue.ToLower());
return ceNewValue.Key.ToString();
}
}
else
{
return ce.Value.ToString();
}
}
public PermissionFilter(int memberId, MemberType memberType, string schemaId, string actionId, string filter) : base(memberId, memberType, schemaId, actionId, false)
{
if(string.IsNullOrWhiteSpace(filter))
throw new ArgumentNullException("filter");
_filter = filter.Trim();
}
internal static StaffMember getMember(HttpSessionStateBase Session ,int memberID,MemberType membertype)
{
Dictionary<String, List<LibraryMemberBase>> librarymembers = Session["LibraryMembers"] as Dictionary<String, List<LibraryMemberBase>>;
List<LibraryMemberBase> staffmemberlist = librarymembers[membertype.ToString()];
StaffMember member = (StaffMember)staffmemberlist.Single(s => s.ID == memberID);
return member;
}
public ReflectionException(string memberName, MemberType type, object obj)
: this(string.Format("Fail to find {0} {1} in {2}."
, memberName
, Enum.GetName(typeof(MemberType), type)
, obj.ToString()))
{
}
public MemberExistsException (string className, string memberName, MemberType existingMemberType, MemberType newMemberType, DomRegion errorLocation, string fileName)
: base (errorLocation, fileName)
{
this.className = className;
this.memberName = memberName;
this.existingMemberType = existingMemberType;
this.newMemberType = newMemberType;
}
public MetaMethodDialog(AgentType agent, MethodDef method, MemberType memberType)
{
InitializeComponent();
this.Owner = MainWindow.Instance;
this.metaMethodPanel.Initialize(true, agent, method, memberType);
}
public ShopGiftItem(DataRow Row)
{
Security.SecurityCounter Counter = new Security.SecurityCounter(-1);
Id = BrickEngine.GetConvertor().ObjectToInt32(Row[Counter.Next]);
BaseId = BrickEngine.GetConvertor().ObjectToInt32(Row[Counter.Next]);
MemberType = (BrickEngine.GetConvertor().ObjectToString(Row[Counter.Next]) == "BASIC") ? MemberType.BASIC : MemberType.VIP;
MemberdaysNeed = BrickEngine.GetConvertor().ObjectToInt32(Row[Counter.Next]);
}
public IEnumerable<IType> FindTypes(MemberType type = MemberType.All, params System.Type[] expectedAttributes)
{
if (type == MemberType.Static)
{
return this.types;
}
return Enumerable.Empty<IType>();
}
public override void VisitMemberType(MemberType memberType)
{
base.VisitMemberType (memberType);
if (parentType == null)
return;
int length = memberType.MemberNameToken.EndLocation.Column - memberType.MemberNameToken.StartLocation.Column;
int offset = memberType.MemberNameToken.StartLocation.Column - 1;
ReplaceType (parentType + "." + memberType.MemberName, memberType.TypeArguments.Count, offset, length, true);
}
public override void VisitMemberType(MemberType memberType)
{
base.VisitMemberType(memberType);
HandleMemberReference(
memberType, memberType.Target, memberType.MemberNameToken, memberType.TypeArguments, NameLookupMode.Type,
script => {
script.Replace(memberType, RefactoringAstHelper.RemoveTarget(memberType));
});
}
internal override sealed void GenerateSyntax(MemberType type, ISymbol symbol, SyntaxDetail syntax, SymbolVisitorAdapter adapter)
{
string syntaxStr = GetSyntaxContent(type, symbol, adapter);
Debug.Assert(!string.IsNullOrEmpty(syntaxStr));
if (string.IsNullOrEmpty(syntaxStr)) return;
syntax.Content[Language] = syntaxStr;
}
public Record(string name, string nickname, Gender gender, DateTime dateOfBirth,
DateTime registrationDate, DateTime? leavingDate, MemberType memberType, Category category)
{
Name = name;
Nickname = nickname;
Gender = gender;
DateOfBirth = dateOfBirth;
RegistrationDate = registrationDate;
LeavingDate = leavingDate;
MemberType = memberType;
Category = category;
}
public IHttpActionResult Post(MemberType MemberType)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_MemberTypesService.Create(MemberType);
return Created(MemberType);
}
public ShopIdentity(FormsAuthenticationTicket ticket)
{
this.ticket = ticket;
string[] ud = ticket.UserData.Split(':');
userId = ticket.Name;
userEmail = ud[0];
userName = ud[1];
userStatus = (MemberStatus)(int.Parse(ud[2]));
userType = (MemberType)(int.Parse(ud[3]));
userLevel = (UserLevel)(int.Parse(ud[4]));
}
internal MemberWithAccess(IClrDeclaredElement declaredElement, AccessRights typeAccessRights,
MemberType memberType, AccessRights memberAccessRights)
{
Contract.Requires(declaredElement != null);
_declaredElement = declaredElement;
MemberName = declaredElement.ShortName;
TypeAccessRights = typeAccessRights;
MemberType = memberType;
_memberAccessRights = memberAccessRights;
}
public Permission(int memberId, MemberType memberType, string schemaId, string actionId, bool granted)
{
if(string.IsNullOrEmpty(schemaId))
throw new ArgumentNullException("schemaId");
if(string.IsNullOrEmpty(actionId))
throw new ArgumentNullException("actionId");
_memberId = memberId;
_memberType = memberType;
_schemaId = schemaId;
_actionId = actionId;
_granted = granted;
}
public void NestedGenericVariableDeclarationStatementTest()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("MyType<string>.InnerClass<int>.InnerInnerClass a;");
AstType type = new MemberType {
Target = new MemberType {
Target = new SimpleType("MyType") { TypeArguments = { new PrimitiveType("string") } },
MemberName = "InnerClass",
TypeArguments = { new PrimitiveType("int") }
},
MemberName = "InnerInnerClass"
};
Assert.IsTrue(new VariableDeclarationStatement(type, "a").IsMatch(lvd));
}
public IEnumerable<PermissionFilter> GetPermissionFilters(int memberId, MemberType memberType)
{
var entity = new PermissionFilterEntity();
var dataAccess = this.EnsureService<IDataAccess>();
var oql = OQL.From(entity)
.Select()
.Where(p => p.Compare(entity.MemberId, "=", memberId) & p.Compare(entity.MemberType, "=", Convert.ConvertValue<byte>(memberType)))
.End();
var entities = dataAccess.Select<PermissionFilterEntity>(oql);
return Mapper.Map<IEnumerable<PermissionFilterEntity>, IEnumerable<PermissionFilter>>(entities);
}
public bool AddPlayers(List<DLPlayer> playerList)
{
using (var session = NHibernateHelper.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
try
{
var memberType = new MemberType
{
Name = "Player"
};
memberType.Init();
SetAudit(memberType);
session.SaveOrUpdate(memberType);
foreach (var dlPlayer in playerList)
{
var member = session.CreateCriteria(typeof (Member))
.List<Member>().FirstOrDefault(x => x.LegacyId.Equals(dlPlayer.LegacyMemberId));
member.AddMemberType(memberType);
SetAudit(member);
session.SaveOrUpdate(member);
var player = new Player
{
PlayerType =
dlPlayer.AgeGroup == "J" ? (int) PlayerType.Junior : (int) PlayerType.Senior,
Nickname = dlPlayer.Nickname,
Member = member
};
SetAudit(player);
session.SaveOrUpdate(player);
}
transaction.Commit();
return true;
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, ex, string.Empty, null);
transaction.Rollback();
return false;
}
}
}
}
private string MemberExpression(ref Expression exp, ref MemberType type, bool?isComparisonOperator)
{
MemberExpression me = ((MemberExpression)exp);
var isPro = (me.Member.Name == "Length") && me.Member.DeclaringType == SqlSugarTool.StringType;
var proIsField = false;
if (isPro)
{
proIsField = me.Expression != null && !UnderNodeTypeIsConstantExpression(me);
}
if (proIsField == false && (me.Expression == null || me.Expression.NodeType != ExpressionType.Parameter))
{
type = MemberType.Value;
object dynInv = null;
if (isPro)
{
exp = me.Expression;
dynInv = CreateSqlElements(exp, ref type, true);
}
else
{
GetMemberValue(ref exp, me, ref dynInv);
}
if (isPro)
{
return(GetProMethod(me.Member.Name, dynInv.ObjToString(), false));
}
if (dynInv != null && dynInv.GetType() == SqlSugarTool.BoolType)
{
dynInv = ConstantBoolDictionary.Where(it => it.Type == SqlSugarTool.BoolType).Single(it => it.OldValue.ToLower() == dynInv.ObjToString().ToLower()).NewValue;
}
if (dynInv == null)
{
return(null);
}
else
{
return(dynInv.ToString());
}
}
else if (isComparisonOperator == false)
{
return("(" + me.Member.Name + "=1)");
}
else
{
if (Type == ResolveExpressType.nT)
{
type = MemberType.Key;
var dbName = exp.ToString();
if (DB != null && DB.IsEnableAttributeMapping && DB._mappingColumns.IsValuable())
{
var preName = dbName.Split('.').First();
if (DB._mappingColumns.Any(it => it.Key == dbName.Split('.').Last()))
{
dbName = preName + "." + DB._mappingColumns.Single(it => dbName.EndsWith("." + it.Key)).Value;
}
}
if (isPro)
{
return(GetProMethod(me.Member.Name, dbName, true));
}
return(dbName);
}
//single T
string name = me.Member.Name;
if (isPro)
{
name = ((me.Expression) as MemberExpression).Member.Name;
}
type = MemberType.Key;
if (DB != null && DB.IsEnableAttributeMapping && DB._mappingColumns.IsValuable())
{
if (DB._mappingColumns.Any(it => it.Key == name))
{
var dbName = DB._mappingColumns.Single(it => it.Key == name).Value;
name = dbName;
}
}
if (isPro)
{
return(GetProMethod(me.Member.Name, name, true));
}
return(name);
}
}
public override void VisitMemberType(MemberType memberType)
{
new TypeBlock(this, memberType).Emit();
}
public InsertMemberCommand(CompositeTypeShape shape, MemberType memberType)
{
this.shape = shape;
this.memberType = memberType;
}
public static bool IsPageLevel(this MemberType type)
{
return(type == MemberType.Namespace || type == MemberType.Class || type == MemberType.Enum || type == MemberType.Delegate || type == MemberType.Interface || type == MemberType.Struct);
}
/// <exception cref="InvalidOperationException">
/// The type does not support the given kind of member.
/// </exception>
public void InsertMember(MemberType type, int index)
{
if (type == MemberType.Field)
{
if (index > FieldCount)
{
index = FieldCount;
}
}
else
{
index -= FieldCount;
if (index > OperationCount)
{
index = OperationCount;
}
}
if (index < 0)
{
index = 0;
}
switch (type)
{
case MemberType.Field:
Field field = AddField();
fields.RemoveAt(FieldCount - 1);
fields.Insert(index, field);
break;
case MemberType.Method:
Method method = AddMethod();
operations.RemoveAt(OperationCount - 1);
operations.Insert(index, method);
break;
case MemberType.Constructor:
Constructor constructor = AddConstructor();
operations.RemoveAt(OperationCount - 1);
operations.Insert(index, constructor);
break;
case MemberType.Destructor:
Destructor destructor = AddDestructor();
operations.RemoveAt(OperationCount - 1);
operations.Insert(index, destructor);
break;
case MemberType.Property:
Property property = AddProperty();
operations.RemoveAt(OperationCount - 1);
operations.Insert(index, property);
break;
case MemberType.Event:
Event _event = AddEvent();
operations.RemoveAt(OperationCount - 1);
operations.Insert(index, _event);
break;
}
}
public Member(string name, Type type, MemberType memberType)
{
Name = name;
Type = type;
MemberType = memberType;
}
internal bool ResolveMapTypes(out Type dictionaryType, out Type keyType, out Type valueType)
{
dictionaryType = keyType = valueType = null;
try
{
var info = MemberType;
if (ImmutableCollectionDecorator.IdentifyImmutable(MemberType, out _, out _, out _, out _, out _, out _))
{
return(false);
}
if (info.IsInterface && info.IsGenericType && info.GetGenericTypeDefinition() == typeof(IDictionary <,>))
{
var typeArgs = MemberType.GetGenericArguments();
if (IsValidMapKeyType(typeArgs[0]))
{
keyType = typeArgs[0];
valueType = typeArgs[1];
dictionaryType = MemberType;
}
return(false);
}
foreach (var iType in MemberType.GetInterfaces())
{
info = iType;
if (info.IsGenericType && info.GetGenericTypeDefinition() == typeof(IDictionary <,>))
{
if (dictionaryType != null)
{
throw new InvalidOperationException("Multiple dictionary interfaces implemented by type: " + MemberType.FullName);
}
var typeArgs = iType.GetGenericArguments();
if (IsValidMapKeyType(typeArgs[0]))
{
keyType = typeArgs[0];
valueType = typeArgs[1];
dictionaryType = MemberType;
}
}
}
if (dictionaryType == null)
{
return(false);
}
// (note we checked the key type already)
// not a map if value is repeated
Type itemType = null, defaultType = null;
model.ResolveListTypes(valueType, ref itemType, ref defaultType);
if (itemType != null)
{
return(false);
}
return(dictionaryType != null);
}
catch
{
// if it isn't a good fit; don't use "map"
return(false);
}
}
internal Member InsertNewMember(MemberType type)
{
int fieldCount = CompositeType.FieldCount;
Member newMember = null;
switch (type)
{
case MemberType.Field:
if (CompositeType.SupportsFields)
{
int index = Math.Min(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Field, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Method:
if (CompositeType.SupportsMethods)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Method, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Constructor:
if (CompositeType.SupportsConstuctors)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Constructor, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Destructor:
if (CompositeType.SupportsDestructors)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Destructor, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Property:
if (CompositeType.SupportsProperties)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Property, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Event:
if (CompositeType.SupportsEvents)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
newMember = CompositeType.InsertMember(MemberType.Event, index);
ActiveMemberIndex = index;
}
break;
default:
throw new ArgumentException($"{type.ToString()} is not a valid member type", nameof(type));
}
return(newMember);
}
AstType ConvertTypeDefinition(ITypeDefinition typeDef, IList <IType> typeArguments)
{
Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
switch (ReflectionHelper.GetTypeCode(typeDef))
{
case TypeCode.Object:
return(new PrimitiveType("object"));
case TypeCode.Boolean:
return(new PrimitiveType("bool"));
case TypeCode.Char:
return(new PrimitiveType("char"));
case TypeCode.SByte:
return(new PrimitiveType("sbyte"));
case TypeCode.Byte:
return(new PrimitiveType("byte"));
case TypeCode.Int16:
return(new PrimitiveType("short"));
case TypeCode.UInt16:
return(new PrimitiveType("ushort"));
case TypeCode.Int32:
return(new PrimitiveType("int"));
case TypeCode.UInt32:
return(new PrimitiveType("uint"));
case TypeCode.Int64:
return(new PrimitiveType("long"));
case TypeCode.UInt64:
return(new PrimitiveType("ulong"));
case TypeCode.Single:
return(new PrimitiveType("float"));
case TypeCode.Double:
return(new PrimitiveType("double"));
case TypeCode.Decimal:
return(new PrimitiveType("decimal"));
case TypeCode.String:
return(new PrimitiveType("string"));
}
// There is no type code for System.Void
if (typeDef.Kind == TypeKind.Void)
{
return(new PrimitiveType("void"));
}
// The number of type parameters belonging to outer classes
int outerTypeParameterCount;
if (typeDef.DeclaringType != null)
{
outerTypeParameterCount = typeDef.DeclaringType.TypeParameterCount;
}
else
{
outerTypeParameterCount = 0;
}
if (resolver != null)
{
// Look if there's an alias to the target type
for (UsingScope usingScope = resolver.UsingScope; usingScope != null; usingScope = usingScope.Parent)
{
foreach (var pair in usingScope.UsingAliases)
{
IType type = pair.Value.Resolve(resolver.Context);
if (TypeMatches(type, typeDef, typeArguments))
{
return(new SimpleType(pair.Key));
}
}
}
IList <IType> localTypeArguments;
if (typeDef.TypeParameterCount > outerTypeParameterCount)
{
localTypeArguments = new IType[typeDef.TypeParameterCount - outerTypeParameterCount];
for (int i = 0; i < localTypeArguments.Count; i++)
{
localTypeArguments[i] = typeArguments[outerTypeParameterCount + i];
}
}
else
{
localTypeArguments = EmptyList <IType> .Instance;
}
TypeResolveResult trr = resolver.ResolveSimpleName(typeDef.Name, localTypeArguments) as TypeResolveResult;
if (trr != null && !trr.IsError && TypeMatches(trr.Type, typeDef, typeArguments))
{
// We can use the short type name
SimpleType shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(shortResult);
}
}
MemberType result = new MemberType();
if (typeDef.DeclaringTypeDefinition != null)
{
// Handle nested types
result.Target = ConvertTypeDefinition(typeDef.DeclaringTypeDefinition, typeArguments);
}
else
{
// Handle top-level types
if (string.IsNullOrEmpty(typeDef.Namespace))
{
result.Target = new SimpleType("global");
result.IsDoubleColon = true;
}
else
{
result.Target = ConvertNamespace(typeDef.Namespace);
}
}
result.MemberName = typeDef.Name;
AddTypeArguments(result, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(result);
}
internal void InsertNewMember(MemberType type)
{
int fieldCount = CompositeType.FieldCount;
switch (type)
{
case MemberType.Field:
if (CompositeType.SupportsFields)
{
int index = Math.Min(ActiveMemberIndex + 1, fieldCount);
bool changing = (index == fieldCount &&
ActiveMember.MemberType != MemberType.Field);
CompositeType.InsertMember(MemberType.Field, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Method:
if (CompositeType.SupportsMethods)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
CompositeType.InsertMember(MemberType.Method, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Constructor:
if (CompositeType.SupportsConstuctors)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
CompositeType.InsertMember(MemberType.Constructor, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Destructor:
if (CompositeType.SupportsDestructors)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
CompositeType.InsertMember(MemberType.Destructor, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Property:
if (CompositeType.SupportsProperties)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
CompositeType.InsertMember(MemberType.Property, index);
ActiveMemberIndex = index;
}
break;
case MemberType.Event:
if (CompositeType.SupportsEvents)
{
int index = Math.Max(ActiveMemberIndex + 1, fieldCount);
CompositeType.InsertMember(MemberType.Event, index);
ActiveMemberIndex = index;
}
break;
}
}
protected void protect_Click(object sender, CommandEventArgs e)
{
if (string.IsNullOrEmpty(errorPagePicker.Value) || errorPagePicker.Value == "-1")
cv_errorPage.IsValid = false;
if (string.IsNullOrEmpty(loginPagePicker.Value) || loginPagePicker.Value == "-1")
cv_loginPage.IsValid = false;
//reset
SimpleLoginNameValidator.IsValid = true;
var provider = MembershipProviderExtensions.GetMembersMembershipProvider();
int pageId = int.Parse(helper.Request("nodeId"));
if (e.CommandName == "simple")
{
var memberLogin = simpleLogin.Visible ? simpleLogin.Text : SimpleLoginLabel.Text;
var member = provider.GetUser(memberLogin, false);
if (member == null)
{
var tempEmail = "u" + Guid.NewGuid().ToString("N") + "@example.com";
// this needs to work differently depending on umbraco members or external membership provider
if (provider.IsUmbracoMembershipProvider() == false)
{
member = provider.CreateUser(memberLogin, simplePassword.Text, tempEmail);
}
else
{
//if it's the umbraco membership provider, then we need to tell it what member type to create it with
if (MemberType.GetByAlias(Constants.Conventions.MemberTypes.SystemDefaultProtectType) == null)
{
MemberType.MakeNew(BusinessLogic.User.GetUser(0), Constants.Conventions.MemberTypes.SystemDefaultProtectType);
}
var castedProvider = provider.AsUmbracoMembershipProvider();
MembershipCreateStatus status;
member = castedProvider.CreateUser(Constants.Conventions.MemberTypes.SystemDefaultProtectType,
memberLogin, simplePassword.Text, tempEmail, null, null, true, null, out status);
if (status != MembershipCreateStatus.Success)
{
SimpleLoginNameValidator.IsValid = false;
SimpleLoginNameValidator.ErrorMessage = "Could not create user: "******"Could not create user: "******"__umbracoRole_" + member.UserName;
if (Roles.RoleExists(simpleRoleName) == false)
{
Roles.CreateRole(simpleRoleName);
}
if (Roles.IsUserInRole(member.UserName, simpleRoleName) == false)
{
Roles.AddUserToRole(member.UserName, simpleRoleName);
}
Access.ProtectPage(true, pageId, int.Parse(loginPagePicker.Value), int.Parse(errorPagePicker.Value));
Access.AddMembershipRoleToDocument(pageId, simpleRoleName);
Access.AddMembershipUserToDocument(pageId, member.UserName);
}
else if (e.CommandName == "advanced")
{
if (cv_errorPage.IsValid && cv_loginPage.IsValid)
{
Access.ProtectPage(false, pageId, int.Parse(loginPagePicker.Value), int.Parse(errorPagePicker.Value));
foreach (ListItem li in _memberGroups.Items)
if (("," + _memberGroups.Value + ",").IndexOf("," + li.Value + ",", StringComparison.Ordinal) > -1)
Access.AddMembershipRoleToDocument(pageId, li.Value);
else
Access.RemoveMembershipRoleFromDocument(pageId, li.Value);
}
else
{
return;
}
}
feedback.Text = ui.Text("publicAccess", "paIsProtected", new cms.businesslogic.CMSNode(pageId).Text) + "</p><p><a href='#' onclick='" + ClientTools.Scripts.CloseModalWindow() + "'>" + ui.Text("closeThisWindow") + "</a>";
p_buttons.Visible = false;
pane_advanced.Visible = false;
pane_simple.Visible = false;
var content = ApplicationContext.Current.Services.ContentService.GetById(pageId);
//reloads the current node in the tree
ClientTools.SyncTree(content.Path, true);
//reloads the current node's children in the tree
ClientTools.ReloadActionNode(false, true);
feedback.type = global::umbraco.uicontrols.Feedback.feedbacktype.success;
}
public HttpResponseMessage EditMemberType([FromBody] MemberType objMemberType)
{
return(Request.CreateResponse(HttpStatusCode.OK, objMemberTypeAccess.EditMemberType(objMemberType)));
}
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia)
{
// Create content
createdContent = new List <IContent>();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah");
ContentTypeService.Save(contentType);
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
createdContent.Add(c1);
}
// Create related content
var relatedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
relatedContent.Add(c1);
}
// Create media
createdMedia = new List <IMedia>();
MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
MediaTypeService.Save(imageType);
for (int i = 0; i < 3; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple");
MemberTypeService.Save(memberType);
createdMembers = MemberBuilder.CreateSimpleMembers(memberType, 3).ToList();
GetMemberService().Save(createdMembers);
IRelationType relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
IRelationType relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias);
// Relate content to media
foreach (IContent content in createdContent)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(content.Id, media.Id, relatedMediaRelType);
}
}
// Relate content to content
foreach (IContent relContent in relatedContent)
{
foreach (IContent content in createdContent)
{
RelationService.Relate(relContent.Id, content.Id, relatedContentRelType);
}
}
// Relate members to media
foreach (IMember member in createdMembers)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(member.Id, media.Id, relatedMediaRelType);
}
}
// Create copied content
var copiedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
copiedContent.Add(c1);
}
IRelationType copiedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias);
// Relate content to content (mimics copy)
foreach (IContent content in createdContent)
{
foreach (IContent cpContent in copiedContent)
{
RelationService.Relate(content.Id, cpContent.Id, copiedContentRelType);
}
}
// Create trashed content
var trashedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
trashedContent.Add(c1);
}
IRelationType trashedRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias);
// Relate to trashed content
foreach (IContent trContent in trashedContent)
{
foreach (IContent content in createdContent)
{
RelationService.Relate(trContent.Id, content.Id, trashedRelType);
}
}
// Create trashed media
var trashedMedia = new List <IMedia>();
for (int i = 0; i < 3; i++)
{
Media m1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(m1);
trashedMedia.Add(m1);
}
IRelationType trashedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias);
// Relate to trashed media
foreach (IMedia trMedia in trashedMedia)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(trMedia.Id, media.Id, trashedMediaRelType);
}
}
}
/// <summary>
/// Removes the target from a member reference while preserving the identifier and type arguments.
/// </summary>
public static SimpleType RemoveTarget(MemberType memberType)
{
return(new SimpleType(memberType.MemberName, memberType.TypeArguments.Select(t => t.Clone())));
}
internal static IMemberCell GetMemberCell(IMemberCell AMemberCell, MemberType AMemberType)
{
return(GetMemberCell2(AMemberCell, AMemberType));
}
public MemberExistsException(string className, string memberName, MemberType existingMemberType, MemberType newMemberType, DomRegion errorLocation, string fileName)
: base(errorLocation, fileName)
{
this.className = className;
this.memberName = memberName;
this.existingMemberType = existingMemberType;
this.newMemberType = newMemberType;
}
private string BinaryExpression(Expression exp)
{
var expression = exp as BinaryExpression;
var isComparisonOperator =
expression.NodeType != ExpressionType.And &&
expression.NodeType != ExpressionType.AndAlso &&
expression.NodeType != ExpressionType.Or &&
expression.NodeType != ExpressionType.OrElse;
MemberType leftType = MemberType.None;
MemberType rightType = MemberType.None;
var leftIsDateTime = expression.Left.Type.ToString().Contains("System.DateTime");
var rightIsDateTime = expression.Right.Type.ToString().Contains("System.DateTime");
var left = CreateSqlElements(expression.Left, ref leftType, true, isComparisonOperator);
var right = CreateSqlElements(expression.Right, ref rightType, true, isComparisonOperator);
var oper = GetOperator(expression.NodeType);
var isKeyOperValue = leftType == MemberType.Key && rightType == MemberType.Value;
var isValueOperKey = rightType == MemberType.Key && leftType == MemberType.Value;
#region 处理 null
if (isKeyOperValue && right.IsGuid() && ConstantBoolDictionary.Any(it => it.Key.ToString() == right))
{
right = ConstantBoolDictionary.Single(it => it.Key.ToString() == right).NewValue;
}
if (isValueOperKey && ConstantBoolDictionary.Any(it => it.Key.ToString() == left))
{
left = ConstantBoolDictionary.Single(it => it.Key.ToString() == left).NewValue;
}
if (isKeyOperValue & (right == "null" || right == null) && oper.Trim() == "=")
{
var oldLeft = AddParas(ref left, right);
return(string.Format(" ({0} is null ) ", oldLeft));
}
else if (isKeyOperValue & (right == "null" || right == null) && oper.Trim() == "<>")
{
var oldLeft = AddParas(ref left, right);
return(string.Format(" ({0} is not null ) ", oldLeft));
}
else if (isValueOperKey & (left == "null" || left == null) && oper.Trim() == "=")
{
return(string.Format(" ({0} is null ) ", right));
}
else if (isValueOperKey & (left == "null" || left == null) && oper.Trim() == "<>")
{
return(string.Format(" ({0} is not null ) ", right));
}
#endregion
else if (isKeyOperValue)
{
object parValue = null;
if (leftIsDateTime && right != null && right.IsDate())
{
parValue = Convert.ToDateTime(right);
}
else
{
parValue = right;
}
if (left.Contains("("))
{
return(string.Format(" ({0} {1} {2}) ", left, oper, right.ToSqlValue()));
}
else
{
var oldLeft = AddParas(ref left, parValue);
return(string.Format(" ({0} {1} " + SqlSugarTool.ParSymbol + "{2}) ", oldLeft.GetTranslationSqlName(), oper, left));
}
}
else if (isValueOperKey)
{
object parValue = null;
if (rightIsDateTime && left != null && left.IsDate())
{
parValue = Convert.ToDateTime(left);
}
else
{
parValue = left;
}
if (right.Contains("("))
{
return(string.Format(" ({0} {1} {2}) ", left.ToSqlValue(), oper, right));
}
else
{
var oldRight = AddParasReturnRight(parValue, ref right);
return(string.Format("( " + SqlSugarTool.ParSymbol + "{0} {1} {2} )", right, oper, oldRight.GetTranslationSqlName()));
}
}
else if (leftType == MemberType.Value && rightType == MemberType.Value)
{
var isAndOr = oper.ObjToString().IsIn("AND", "OR");
if (isAndOr)
{
return(string.Format("( {0} {1} {2} )", left, oper, right));
}
else
{
return(string.Format("( '{0}' {1} '{2}' )", left, oper, right));
}
}
else
{
return(string.Format("( {0} {1} {2} )", left, oper, right));
}
}
AstType ConvertTypeDefinition(ITypeDefinition typeDef, IList <IType> typeArguments)
{
Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
switch (ReflectionHelper.GetTypeCode(typeDef))
{
case TypeCode.Object:
return(new PrimitiveType("object"));
case TypeCode.Boolean:
return(new PrimitiveType("bool"));
case TypeCode.Char:
return(new PrimitiveType("char"));
case TypeCode.SByte:
return(new PrimitiveType("sbyte"));
case TypeCode.Byte:
return(new PrimitiveType("byte"));
case TypeCode.Int16:
return(new PrimitiveType("short"));
case TypeCode.UInt16:
return(new PrimitiveType("ushort"));
case TypeCode.Int32:
return(new PrimitiveType("int"));
case TypeCode.UInt32:
return(new PrimitiveType("uint"));
case TypeCode.Int64:
return(new PrimitiveType("long"));
case TypeCode.UInt64:
return(new PrimitiveType("ulong"));
case TypeCode.Single:
return(new PrimitiveType("float"));
case TypeCode.Double:
return(new PrimitiveType("double"));
case TypeCode.Decimal:
return(new PrimitiveType("decimal"));
case TypeCode.String:
return(new PrimitiveType("string"));
}
// There is no type code for System.Void
if (typeDef != null && typeDef.Namespace == "System" && typeDef.Name == "Void" && typeDef.TypeParameterCount == 0)
{
return(new PrimitiveType("void"));
}
if (resolver != null && TypeArgumentsTrivial(typeArguments, OuterTypeParameterCount(typeDef)))
{
TypeResolveResult trr = resolver.ResolveSimpleName(typeDef.Name, typeArguments) as TypeResolveResult;
if (trr != null && !trr.IsError && trr.Type.GetDefinition() == typeDef)
{
// We can use the short type name
SimpleType shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeArguments, OuterTypeParameterCount(typeDef), typeDef.TypeParameterCount);
return(shortResult);
}
}
MemberType result = new MemberType();
if (typeDef.DeclaringTypeDefinition != null)
{
// Handle nested types
result.Target = ConvertTypeDefinition(typeDef.DeclaringTypeDefinition, typeArguments);
}
else
{
// Handle top-level types
if (string.IsNullOrEmpty(typeDef.Namespace))
{
result.Target = new SimpleType("global");
result.IsDoubleColon = true;
}
else
{
result.Target = ConvertNamespace(typeDef.Namespace);
}
}
result.MemberName = typeDef.Name;
AddTypeArguments(result, typeArguments, OuterTypeParameterCount(typeDef), typeDef.TypeParameterCount);
return(result);
}
internal ShipMember(ulong id, MemberType type, bool status)
{
Id = id;
Type = type;
Status = status;
}
public MemberExpression(MemberType type, params string[] members)
: this(type, members.Select(p => new MemberExpressionComponent(p, null)).ToArray())
{
}
public void CompilationSucceedsOnStringOrCharArrayType(MemberType memberType, [CombinatorialValues(typeof(string), typeof(char[]))] Type type)
{
var result = Transform.FromAttributeSource(memberType, type, "[ValidationAttributes.Strings.NotNullOrWhiteSpaceAttribute]");
Assert.True(result.Success);
}
public IEnumerable <MemberResult> GetMembers(Genero4glAst ast, MemberType memberType, bool function)
{
return(_memberFunctions.Values.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, ast)));
}
public override void VisitMemberType(MemberType memberType)
{
this.CheckType(memberType);
base.VisitMemberType(memberType);
}
void EmitFieldSize(int buffer_size)
{
int type_size = BuiltinTypeSpec.GetSize(MemberType);
if (buffer_size > int.MaxValue / type_size)
{
Report.Error(1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError(), buffer_size.ToString(), MemberType.GetSignatureForError());
return;
}
AttributeEncoder encoder;
var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve(Location);
var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve(Location);
if (field_size == null || field_charset == null)
{
return;
}
var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
encoder = new AttributeEncoder();
encoder.Encode((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments(
new [] { field_size, field_charset },
new Constant [] {
new IntConstant(Compiler.BuiltinTypes, buffer_size * type_size, Location),
new IntConstant(Compiler.BuiltinTypes, (int)char_set, Location)
}
);
fixed_buffer_type.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
{
return;
}
ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
encoder = new AttributeEncoder();
encoder.EncodeTypeName(MemberType);
encoder.Encode(buffer_size);
encoder.EncodeEmptyNamedArguments();
FieldBuilder.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
}
public void VisitMemberType(MemberType memberType)
{
throw new NotImplementedException();
}
public Node VisitMemberType(MemberType memberType)
{
return(CreateDummy(memberType));
}
/// <summary>
/// Allow multiple items in one yml file
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static bool AllowMultipleItems(this MemberType type)
{
return(type == MemberType.Class || type == MemberType.Enum || type == MemberType.Delegate || type == MemberType.Interface || type == MemberType.Struct);
}
AstType ConvertTypeHelper(ITypeDefinition typeDef, IList <IType> typeArguments)
{
Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
string keyword = KnownTypeReference.GetCSharpNameByTypeCode(typeDef.KnownTypeCode);
if (keyword != null)
{
return(new PrimitiveType(keyword));
}
// The number of type parameters belonging to outer classes
int outerTypeParameterCount;
if (typeDef.DeclaringType != null)
{
outerTypeParameterCount = typeDef.DeclaringType.TypeParameterCount;
}
else
{
outerTypeParameterCount = 0;
}
if (resolver != null)
{
// Look if there's an alias to the target type
if (UseAliases)
{
for (ResolvedUsingScope usingScope = resolver.CurrentUsingScope; usingScope != null; usingScope = usingScope.Parent)
{
foreach (var pair in usingScope.UsingAliases)
{
if (pair.Value is TypeResolveResult)
{
if (TypeMatches(pair.Value.Type, typeDef, typeArguments))
{
return(new SimpleType(pair.Key));
}
}
}
}
}
IList <IType> localTypeArguments;
if (typeDef.TypeParameterCount > outerTypeParameterCount)
{
localTypeArguments = new IType[typeDef.TypeParameterCount - outerTypeParameterCount];
for (int i = 0; i < localTypeArguments.Count; i++)
{
localTypeArguments[i] = typeArguments[outerTypeParameterCount + i];
}
}
else
{
localTypeArguments = EmptyList <IType> .Instance;
}
ResolveResult rr = resolver.ResolveSimpleName(typeDef.Name, localTypeArguments);
TypeResolveResult trr = rr as TypeResolveResult;
if (trr != null || (localTypeArguments.Count == 0 && resolver.IsVariableReferenceWithSameType(rr, typeDef.Name, out trr)))
{
if (!trr.IsError && TypeMatches(trr.Type, typeDef, typeArguments))
{
// We can use the short type name
SimpleType shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(shortResult);
}
}
}
if (AlwaysUseShortTypeNames)
{
var shortResult = new SimpleType(typeDef.Name);
AddTypeArguments(shortResult, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(shortResult);
}
MemberType result = new MemberType();
if (typeDef.DeclaringTypeDefinition != null)
{
// Handle nested types
result.Target = ConvertTypeHelper(typeDef.DeclaringTypeDefinition, typeArguments);
}
else
{
// Handle top-level types
if (string.IsNullOrEmpty(typeDef.Namespace))
{
result.Target = new SimpleType("global");
result.IsDoubleColon = true;
}
else
{
result.Target = ConvertNamespace(typeDef.Namespace);
}
}
result.MemberName = typeDef.Name;
AddTypeArguments(result, typeDef, typeArguments, outerTypeParameterCount, typeDef.TypeParameterCount);
return(result);
}
internal static Member GetMember(IMemberCell AMemberCell, MemberType AMemberType)
{
var m = GetMemberCell(AMemberCell, AMemberType);
return(m != null ? m.Member : null);
}
public MemberExistsException(string className, System.CodeDom.CodeTypeMember newMember, MemberType existingMemberType, DomRegion errorLocation, string fileName)
: this(className, newMember.Name, GetMemberTypeFromCodeTypeMember(newMember), existingMemberType, errorLocation, fileName)
{
}
