C# TypeBase类代码示例

        internal static WebFile FromDbValue(WebFile file, string content, TypeBase type)
        {
            /*if (url == null) return null;
            var u = url.AsUri();
            var file =
                type == TypeBase.WebImage ? WebImage.FromUrl(u) :
                type == TypeBase.WebAudio ? WebAudio.FromUrl(u) :
                type == TypeBase.WebVideo ? WebVideo.FromUrl(u) :
                WebFile.FromUrl(u);
                */
            if (content != null)
            {
                var serializer = new JsonSerializer();

                serializer.AddAwdeeConverters();
                using (var sr = new StringReader(content))
                using (var jr = Utils.CreateJsonReader(sr))
                {
                    serializer.Deserialize(jr, type.NativeType);
                }

            }

            return file;
        }

        public RegisterFrameResource(Frame frame, TypeBase type, Register register)
            : base(frame, type)
        {
            Register = register;

            if (type is PointerType)
            {
                _type = OperandValueType.Dword;
            }
            else
            {
                var typePrim = type as PrimitiveType;
                if (typePrim == null)
                    throw new ArgumentException("Type must be a primitive.", nameof(type));

                switch (typePrim.Type)
                {
                    case Primitive.Int:
                        _type = OperandValueType.Dword;
                        break;
                    case Primitive.Short:
                        _type = OperandValueType.Word;
                        break;
                    case Primitive.Char:
                        _type = OperandValueType.Byte;
                        break;
                    default:
                        throw new NotSupportedException();
                }
            }
        }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            return other is BoolType;
        }

 internal SymmetricClosureService(TypeBase source)
 {
     Source = source;
     AllFeatures = source
         .SymmetricFeatureClosure()
         .ToArray();
 }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            return other is BoolType;
        }

 int CreateFunctionInstance(TypeBase args, FunctionSyntax syntax, CompoundView compoundView)
 {
     var index = _list.Count;
     var f = new FunctionType(index, syntax, compoundView, args);
     _list.Add(f);
     return index;
 }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            return IsConstant == other.IsConstant && other is PointerType;
        }

 internal Value(Func<Category, Result> function, TypeBase source)
     : base(_nextObjectId++)
 {
     Function = function;
     Source = source;
     Tracer.Assert(Source != null);
 }

        public ArrayType(TypeBase innerType, int count, bool constant = false)
            : base(innerType, constant)
        {
            if (count <= 0)
                throw new ArgumentOutOfRangeException(nameof(count));

            Count = count;
        }

        protected TypeModifier(TypeBase innerType, bool constant = false)
            : base(constant)
        {
            if (innerType == null)
                throw new ArgumentNullException(nameof(innerType));

            InnerType = innerType;
        }

 internal Function(ContextBase parent, TypeBase argsType, TypeBase valueType = null)
     : base(parent)
 {
     _order = CodeArgs.NextOrder++;
     ArgsType = argsType;
     ValueType = valueType;
     StopByObjectIds();
 }

 internal Conversion(Func<Category, Result> function, TypeBase source)
     : base(_nextObjectId++)
 {
     Function = function;
     Source = source;
     Tracer.Assert(Source != null);
     StopByObjectIds();
 }

        internal Result Result(Category category, Result leftResult, TypeBase right)
        {
            var rightResult = right
                .Conversion(category.Typed, IndexType)
                .AutomaticDereferencedAlignedResult();

            return Result(category, leftResult + rightResult);
        }

 public static SearchResult Create(IImplementation feature, TypeBase definingItem)
 {
     var searchResult = feature as SearchResult;
     if(searchResult == null)
         return new SearchResult(feature, definingItem);
     var source = searchResult.Source;
     Tracer.Assert(source == definingItem);
     return searchResult;
 }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            if (depth > 0 && other is AnyType)
                return true;

            return Equals(other);
        }