Exemplo n.º 1
0
        public void ReturnsCastObject()
        {
            var expected = new InvalidCastException();

            var actual = Assert.IsAssignableFrom<InvalidCastException>(expected);

            Assert.Same(expected, actual);
        }
 public bool PosTest1()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("PosTest1:Initialize the InvalidCastException instance");
     try
     {
         InvalidCastException myException = new InvalidCastException();
         if (myException == null)
         {
             TestLibrary.TestFramework.LogError("001", "the InvalidCastException instance creating failed");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
Exemplo n.º 3
0
 public bool PosTest2()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("PosTest2:Initialize the InvalidCastException instance with message 2");
     try
     {
         string message = null;
         InvalidCastException myException = new InvalidCastException(message);
         if (myException == null || myException.Message == null)
         {
             TestLibrary.TestFramework.LogError("003", "Initialize the InvalidCastException instance with null message not create");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
Exemplo n.º 4
0
 public bool PosTest1()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("PosTest1:Initialize the InvalidCastException instance with message 1");
     try
     {
         string message = "HelloWorld";
         InvalidCastException myException = new InvalidCastException(message);
         if (myException == null || myException.Message != message)
         {
             TestLibrary.TestFramework.LogError("001", "the InvalidCastException with message instance creating failed");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
 public bool PosTest3()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("PosTest3:Initialize the InvalidCastException instance with message and InnerException 3");
     try
     {
         string message = null;
         InvalidCastException myException = new InvalidCastException(message, null);
         if (myException == null || myException.Message == null || myException.InnerException != null)
         {
             TestLibrary.TestFramework.LogError("005", "Initialize the InvalidCastException instance with null message and null InnerException not succeed");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
 public bool PosTest2()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("PosTest2:Initialize the InvalidCastException instance with message and InnerException 2");
     try
     {
         string message = null;
         ArgumentException innerException = new ArgumentException();
         InvalidCastException myException = new InvalidCastException(message, innerException);
         if (myException == null || myException.Message == null || !myException.InnerException.Equals(innerException))
         {
             TestLibrary.TestFramework.LogError("003", "Initialize the InvalidCastException instance with null message not succeed");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
Exemplo n.º 7
0
        // returns false with both outs null for no such feature
        internal static bool TryParseFeature(string featureString, PluginLoader.PluginMetadata plugin,
                                             out Feature feature, out Exception failException, out bool featureValid, out FeatureParse parsed,
                                             FeatureParse?preParsed = null)
        {
            failException = null;
            feature       = null;
            featureValid  = false;

            if (preParsed == null)
            {
                var    builder    = new StringBuilder();
                string name       = null;
                var    parameters = new List <string>();

                bool escape           = false;
                int  parens           = 0;
                bool removeWhitespace = true;
                foreach (var chr in featureString)
                {
                    if (escape)
                    {
                        builder.Append(chr);
                        escape = false;
                    }
                    else
                    {
                        switch (chr)
                        {
                        case '\\':
                            escape = true;
                            break;

                        case '(':
                            parens++;
                            if (parens != 1)
                            {
                                goto default;
                            }
                            removeWhitespace = true;
                            name             = builder.ToString();
                            builder.Clear();
                            break;

                        case ')':
                            parens--;
                            if (parens != 0)
                            {
                                goto default;
                            }
                            goto case ',';

                        case ',':
                            if (parens > 1)
                            {
                                goto default;
                            }
                            parameters.Add(builder.ToString());
                            builder.Clear();
                            removeWhitespace = true;
                            break;

                        default:
                            if (removeWhitespace && !char.IsWhiteSpace(chr))
                            {
                                removeWhitespace = false;
                            }
                            if (!removeWhitespace)
                            {
                                builder.Append(chr);
                            }
                            break;
                        }
                    }
                }

                if (name == null)
                {
                    name = builder.ToString();
                }

                parsed = new FeatureParse(name, parameters.ToArray());

                if (parens != 0)
                {
                    failException = new Exception("Malformed feature definition");
                    return(false);
                }
            }
            else
            {
                parsed = preParsed.Value;
            }

            if (!featureTypes.TryGetValue(parsed.Name, out var featureType))
            {
                return(false);
            }

            try
            {
                if (!(Activator.CreateInstance(featureType) is Feature aFeature))
                {
                    failException = new InvalidCastException("Feature type not a subtype of Feature");
                    return(false);
                }

                featureValid = aFeature.Initialize(plugin, parsed.Parameters);
                feature      = aFeature;
                return(true);
            }
            catch (Exception e)
            {
                failException = e;
                return(false);
            }
        }
Exemplo n.º 8
0
        private static void FindMemberCastFailByName(ModelContext ctx, IDataReader dr, InvalidCastException ex)
        {
            var text = new StringBuilder();
            var ms   = ctx.Info.SimpleMembers;

            foreach (var member in ms)
            {
                CheckMemberCast(member, dr[member.Name], text);
            }
            if (text.Length > 0)
            {
                throw new DataException(text.ToString(), ex);
            }
        }
Exemplo n.º 9
0
 /// <summary>
 /// Errors the message.
 /// </summary>
 /// <param name="functionName">Name of the function.</param>
 /// <param name="e">The e.</param>
 /// <returns>System.String.</returns>
 private static string ErrorMessage(string functionName, InvalidCastException e) => $"{ClassLocation}.{functionName} - {e.Message}";
Exemplo n.º 10
0
 public void IsTypeReturnsCastObject()
 {
     InvalidCastException expected = new InvalidCastException();
     InvalidCastException actual = Assert.IsType<InvalidCastException>(expected);
     Assert.Same(expected, actual);
 }
        public static void Ctor_Empty()
        {
            var exception = new InvalidCastException();

            ExceptionHelpers.ValidateExceptionProperties(exception, hResult: COR_E_INVALIDCAST, validateMessage: false);
        }
Exemplo n.º 12
0
        internal static InvalidCastException InvalidCast()
        {
            InvalidCastException e = new InvalidCastException();

            return(e);
        }
Exemplo n.º 13
0
        /// <summary>
        /// 单播,根据指令,通过反射创建一个对象,返回该处理方, 并默认不传递消息;
        /// </summary>
        /// <param name="fullName"></param>
        /// <param name="name"></param>
        /// <param name="jsonData"></param>
        /// <returns></returns>
        public static bool CreateDispose(JsonData jsonData = null, string name = null)
        {
            // 这里因为 IDictionary 的 key 和 value 都是 ICollection ,所以只能这样遍历;

            if (name == null)
            {
                name = jsonData.FirstKey();
            }

            IInstructionDispose dispose = FindDispose(name);

            if (dispose != null)
            {
                return(dispose.Dispose(jsonData));
            }


            // 在组件内部反射响应的类,如果没有找到,不抛异常;进而调用客户端注册的方法;

            // 可以加一个配置文件,以读取相应的配置文件,找对应的类;TODO

            // 这里先调用客户端注册的方法;

            Type type = Type.GetType(fullName + "." + name, false, true);

            if (type == null)
            {
                Func <JsonData, bool> func = CustomFunctionLibrary <JsonData> .GetFunc(name);

                Action action = CustomFunctionLibrary <JsonData> .GetAction(name);

                if (func != null)
                {
                    return(func(jsonData));
                }
                if (action != null)
                {
                    action();

                    return(true);
                }

#if UNITY_EDITOR
                throw new NullReferenceException("没有找到指定的类");
#endif
                return(false);                // 不抛异常
            }

            try
            {
                dispose = ((IInstructionDispose)type.Assembly.CreateInstance(type.FullName, true));
            }
            catch (InvalidCastException e)
            {
                e = new InvalidCastException("没有继承 CommandDisposeBase 类");

                throw e;
            }

            dicts.Add(name, dispose);

            return(dispose.Dispose(jsonData));
        }
Exemplo n.º 14
0
        public void ExecuteTestGeneric(object sender, object target)
        {
            var testContent1 = new InvalidOperationException();
            var testContent2 = new InvalidCastException();

            Exception receivedContent1 = null;
            Exception receivedContent2 = null;

            object receivedSender = null;
            object receivedTarget = null;

            Messenger.Reset();

            Messenger.Default.Register <CommandMessage <Exception> >(this,
                                                                     m =>
            {
                receivedSender = m.Sender;
                receivedTarget = m.Target;

                if (m.Command == DummyCommand1)
                {
                    receivedContent1 = testContent1;
                    return;
                }

                if (m.Command == DummyCommand2)
                {
                    receivedContent2 = testContent2;
                    return;
                }
            });

            Assert.AreEqual(null, receivedContent1);
            Assert.AreEqual(null, receivedContent2);

            CommandMessage <Exception> commandMessage1;
            CommandMessage <Exception> commandMessage2;

            if (sender == null)
            {
                commandMessage1 = new CommandMessage <Exception>(testContent1, DummyCommand1);
                commandMessage2 = new CommandMessage <Exception>(testContent2, DummyCommand2);
            }
            else
            {
                if (target == null)
                {
                    commandMessage1 = new CommandMessage <Exception>(sender, testContent1, DummyCommand1);
                    commandMessage2 = new CommandMessage <Exception>(sender, testContent2, DummyCommand2);
                }
                else
                {
                    commandMessage1 = new CommandMessage <Exception>(sender, target, testContent1, DummyCommand1);
                    commandMessage2 = new CommandMessage <Exception>(sender, target, testContent2, DummyCommand2);
                }
            }

            Messenger.Default.Send(commandMessage1);

            Assert.AreEqual(sender, receivedSender);
            Assert.AreEqual(target, receivedTarget);
            Assert.AreEqual(testContent1, receivedContent1);
            Assert.AreEqual(null, receivedContent2);

            receivedSender = null;
            receivedTarget = null;

            Messenger.Default.Send(commandMessage2);

            Assert.AreEqual(sender, receivedSender);
            Assert.AreEqual(target, receivedTarget);
            Assert.AreEqual(testContent1, receivedContent1);
            Assert.AreEqual(testContent2, receivedContent2);
        }
Exemplo n.º 15
0
        public void MatchingType()
        {
            var expected = new InvalidCastException();

            Assert.IsType(typeof(InvalidCastException), expected);
        }
Exemplo n.º 16
0
        public void BaseType()
        {
            var expected = new InvalidCastException();

            Assert.IsAssignableFrom(typeof(Exception), expected);
        }
Exemplo n.º 17
0
        public void MatchingType()
        {
            var expected = new InvalidCastException();

            Assert.IsType <InvalidCastException>(expected);
        }
Exemplo n.º 18
0
        public void SameType()
        {
            var expected = new InvalidCastException();

            Assert.IsAssignableFrom <InvalidCastException>(expected);
        }
Exemplo n.º 19
0
        public void UnmatchedType()
        {
            var expected = new InvalidCastException();

            Assert.IsNotType(typeof(Exception), expected);
        }
        public void Model_InvalidCast()
        {
            InvalidCastException ex = Assert.Throws <InvalidCastException>(() => Function.Model <Models.WrongModel>("public.return_model", null, this.Common.ConnectionString));

            Assert.NotNull(ex);
        }
Exemplo n.º 21
0
 private bool ExceptionFromDynamicReflection(InvalidCastException e)
 {
     return(e.TargetSite.DeclaringType.FullName.IndexOf(DynamicReflectionManager.ASSEMBLY_NAME) >= 0);
 }
Exemplo n.º 22
0
        static internal InvalidCastException InvalidCast(string error, Exception inner)
        {
            InvalidCastException e = new InvalidCastException(error, inner);

            return(e);
        }
Exemplo n.º 23
0
        public void UnmatchedType()
        {
            InvalidCastException expected = new InvalidCastException();

            Assert.IsNotType(typeof(Exception), expected);
        }
Exemplo n.º 24
0
        public void TestSimple()
        {
            var cause = new InvalidCastException();

            Assert.Throws <RabbitRejectAndDontRequeueException>(() => DoTest(cause));
        }
Exemplo n.º 25
0
        public void MatchingType()
        {
            InvalidCastException expected = new InvalidCastException();

            Assert.IsType<InvalidCastException>(expected);
        }
Exemplo n.º 26
0
        /// <summary>
        /// Initializes the command's request object.
        /// </summary>
        /// <param name="cmdletInformation">
        /// The information about the cmdlet.
        /// </param>
        /// <exception cref="CmdletInvocationException">
        /// If the constructor for the cmdlet threw an exception.
        /// </exception>
        /// <exception cref="MemberAccessException">
        /// The type referenced by <paramref name="cmdletInformation"/> refered to an
        /// abstract type or them member was invoked via a late-binding mechanism.
        /// </exception>
        /// <exception cref="TypeLoadException">
        /// If <paramref name="cmdletInformation"/> refers to a type that is invalid.
        /// </exception>
        private void Init(CmdletInfo cmdletInformation)
        {
            Diagnostics.Assert(cmdletInformation != null, "Constructor should throw exception if LookupCommand returned null.");

            Cmdlet    newCmdlet            = null;
            Exception initError            = null;
            string    errorIdAndResourceId = null;
            string    resourceStr          = null;

            try
            {
                // Create the request object
                newCmdlet = ConstructInstance(cmdletInformation.ImplementingType);
                if (newCmdlet == null)
                {
                    // We could test the inheritance before constructing, but that's
                    // expensive.  Much cheaper to just check for null.
                    initError            = new InvalidCastException();
                    errorIdAndResourceId = "CmdletDoesNotDeriveFromCmdletType";
                    resourceStr          = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
                }
            }
            catch (MemberAccessException memberAccessException)
            {
                initError = memberAccessException;
            }
            catch (TypeLoadException typeLoadException)
            {
                initError = typeLoadException;
            }
            catch (Exception e) // Catch-all OK, 3rd party callout.
            {
                // We don't have a Command or InvocationInfo at this point,
                // since the command failed to initialize.
                var commandException = new CmdletInvocationException(e, null);

                // Log a command health event
                MshLog.LogCommandHealthEvent(
                    this._context,
                    commandException,
                    Severity.Warning);

                throw commandException;
            }

            if (initError != null)
            {
                // Log a command health event
                MshLog.LogCommandHealthEvent(
                    this._context,
                    initError,
                    Severity.Warning);

                CommandNotFoundException exception =
                    new CommandNotFoundException(
                        cmdletInformation.Name,
                        initError,
                        errorIdAndResourceId ?? "CmdletNotFoundException",
                        resourceStr ?? DiscoveryExceptions.CmdletNotFoundException,
                        initError.Message);
                throw exception;
            }

            this.Command      = newCmdlet;
            this.CommandScope = Context.EngineSessionState.CurrentScope;

            InitCommon();
        }
Exemplo n.º 27
0
        public void MatchingType()
        {
            InvalidCastException expected = new InvalidCastException();

            Assert.IsType(typeof(InvalidCastException), expected);
        }
Exemplo n.º 28
0
        /// <summary>
        /// Initializes the command's request object
        /// </summary>
        /// 
        /// <param name="cmdletInformation">
        /// The information about the cmdlet.
        /// </param>
        /// 
        /// <exception cref="CmdletInvocationException">
        /// If the constructor for the cmdlet threw an exception.
        /// </exception>
        /// 
        /// <exception cref="MemberAccessException">
        /// The type referenced by <paramref name="cmdletInformation"/> refered to an
        /// abstract type or them member was invoked via a late-binding mechanism.
        /// </exception>
        /// 
        /// <exception cref="TypeLoadException">
        /// If <paramref name="cmdletInformation"/> refers to a type that is invalid.
        /// </exception>
        /// 
        private void Init(CmdletInfo cmdletInformation)
        {
            Diagnostics.Assert(cmdletInformation != null, "Constructor should throw exception if LookupCommand returned  null.");

            Cmdlet newCmdlet = null;
            Exception initError = null;
            string errorIdAndResourceId = null;
            string resourceStr = null;
            try
            {
                // Create the request object
                newCmdlet = ConstructInstance(cmdletInformation.ImplementingType);
                if (newCmdlet == null)
                {
                    // We could test the inheritance before constructing, but that's
                    // expensive.  Much cheaper to just check for null.
                    initError = new InvalidCastException();
                    errorIdAndResourceId = "CmdletDoesNotDeriveFromCmdletType";
                    resourceStr = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
                }
            }
            catch (MemberAccessException memberAccessException)
            {
                initError = memberAccessException;
            }
            catch (TypeLoadException typeLoadException)
            {
                initError = typeLoadException;
            }
            catch (Exception e) // Catch-all OK, 3rd party callout.
            {
                CommandProcessorBase.CheckForSevereException(e);

                // We don't have a Command or InvocationInfo at this point,
                // since the command failed to initialize.
                var commandException = new CmdletInvocationException(e, null);

                // Log a command health event
                MshLog.LogCommandHealthEvent(
                    this._context,
                    commandException,
                    Severity.Warning);

                throw commandException;
            }
            if (null != initError)
            {
                // Log a command health event
                MshLog.LogCommandHealthEvent(
                    this._context,
                    initError,
                    Severity.Warning);

                CommandNotFoundException exception =
                    new CommandNotFoundException(
                        cmdletInformation.Name,
                        initError,
                        errorIdAndResourceId ?? "CmdletNotFoundException",
                        resourceStr ?? DiscoveryExceptions.CmdletNotFoundException,
                        initError.Message);
                throw exception;
            }

            this.Command = newCmdlet;
            this.CommandScope = Context.EngineSessionState.CurrentScope;

            InitCommon();
        }
Exemplo n.º 29
0
 public void IsNotType()
 {
     InvalidCastException expected = new InvalidCastException();
     Assert.IsNotType(typeof(Exception), expected);
     Assert.IsNotType<Exception>(expected);
 }
Exemplo n.º 30
0
        internal ConnectionPointCookie(object source, object sink, Type eventInterface)
        {
            Exception ex = null;

            if (source is UnsafeNativeMethods.IConnectionPointContainer)
            {
                UnsafeNativeMethods.IConnectionPointContainer cpc = (UnsafeNativeMethods.IConnectionPointContainer)source;

                try
                {
                    Guid tmp = eventInterface.GUID;
                    if (cpc.FindConnectionPoint(ref tmp, out connectionPoint) != NativeMethods.S_OK)
                    {
                        connectionPoint = null;
                    }
                }
                catch (Exception e)
                {
                    if (CriticalExceptions.IsCriticalException(e))
                    {
                        throw;
                    }

                    connectionPoint = null;
                }

                if (connectionPoint == null)
                {
                    ex = new ArgumentException(SR.Get(SRID.AxNoEventInterface, eventInterface.Name));
                }
                // IsComObject(sink): this is the case of a managed sink object wrapped in IDispatchSTAForwarder -
                // see WebBrowser.CreateSink().
                else if (sink == null || !eventInterface.IsInstanceOfType(sink) && !Marshal.IsComObject(sink))
                {
                    ex = new InvalidCastException(SR.Get(SRID.AxNoSinkImplementation, eventInterface.Name));
                }
                else
                {
                    int hr = connectionPoint.Advise(sink, ref cookie);
                    if (hr != NativeMethods.S_OK)
                    {
                        cookie = 0;
                        Marshal.FinalReleaseComObject(connectionPoint);
                        connectionPoint = null;
                        ex = new InvalidOperationException(SR.Get(SRID.AxNoSinkAdvise, eventInterface.Name, hr));
                    }
                }
            }
            else
            {
                ex = new InvalidCastException(SR.Get(SRID.AxNoConnectionPointContainer));
            }


            if (connectionPoint == null || cookie == 0)
            {
                if (connectionPoint != null)
                {
                    Marshal.FinalReleaseComObject(connectionPoint);
                }

                if (ex == null)
                {
                    throw new ArgumentException(SR.Get(SRID.AxNoConnectionPoint, eventInterface.Name));
                }
                else
                {
                    throw ex;
                }
            }
        }
Exemplo n.º 31
0
        //Evento de carga del formulario principal
        private void FormPrincipal_Load(object sender, EventArgs e)
        {
            InvalidCastException icEx = new InvalidCastException();

            try
            {
                creaDataset();
            }
            catch
            {
                MessageBox.Show("In order to use this app your SQL must be active" + Environment.NewLine + "The program will now close");
                this.Close();
            }

            try
            {
                //INICIO
                foreach (DataTable dt in ds.Tables)
                {
                    if (dt.TableName.Equals("Artists"))
                    {
                        foreach (DataRow dr in dt.Rows)
                        {
                            if (dr.IsNull("Genre") || dr.IsNull("Labels") || dr.IsNull("RealName"))
                            {
                                throw icEx;
                            }
                            addedArtist = new Artist(dr[0] + "", dr[1] + "", dr[2] + "", dr[3] + "");
                            artists.Add(addedArtist);
                            lbArtist.Items.Add(addedArtist.Name);
                        }
                    }

                    if (dt.TableName.Equals("Albums"))
                    {
                        foreach (DataRow dr in dt.Rows)
                        {
                            if (dr.IsNull("ReleaseMonth") || dr.IsNull("ReleaseCountry") || dr.IsNull("RecordLabel") || dr.IsNull("Genre") || dr.IsNull("AlbumArtist"))
                            {
                                throw icEx;
                            }
                            addedAlbum = new Album(dr[0] + "", Convert.ToInt32(dr[1]), dr[2] + "", Convert.ToInt32(dr[3]), dr[4] + "", dr[5] + "", dr[6] + "", Convert.ToInt32(dr[7]), Convert.ToInt32(dr[8]), dr[9] + "");
                            albums.Add(addedAlbum);
                            lbAlbum.Items.Add(addedAlbum.Title);
                        }
                    }
                    if (dt.TableName.Equals("Songs"))
                    {
                        foreach (DataRow dr in dt.Rows)
                        {
                            if (dr.IsNull("Album") || dr.IsNull("Artist") || dr.IsNull("Genre"))
                            {
                                throw icEx;
                            }
                            addedSong = new Song(dr[0] + "", dr[1] + "", dr[2] + "", Convert.ToInt32(dr[3]), Convert.ToInt32(dr[4]), dr[5] + "");
                            songs.Add(addedSong);
                            lbSong.Items.Add(addedSong.SongName);
                        }
                    }
                }
            }
            catch (System.InvalidCastException icExG)
            {
                MessageBox.Show("Your database can't contain NULL values, the program will now finish");

                this.Close();
            }
            this.Refresh();
        }
Exemplo n.º 32
0
 public void IsAssignableFrom_BaseType()
 {
     var expected = new InvalidCastException();
     Assert.IsAssignableFrom(typeof(Exception), expected);
     Assert.IsAssignableFrom<Exception>(expected);
 }
Exemplo n.º 33
0
 public InvalidCast_Exception(InvalidCastException ex) : base(ex.Message, ex)
 {
     LoggerConfiguration.DefaultSetup();
     this.LoggerException();
 }
            /// <include file='doc\NativeMethods.uex' path='docs/doc[@for="NativeMethods.ConnectionPointCookie.ConnectionPointCookie1"]/*' />
            /// <devdoc>
            /// Creates a connection point to of the given interface type.
            /// which will call on a managed code sink that implements that interface.
            /// </devdoc>
            public ConnectionPointCookie(object source, object sink, Type eventInterface, bool throwException, out bool connected){
                connected = false;
                Exception ex = null;
                if (source is UnsafeNativeMethods.IConnectionPointContainer) {
                    UnsafeNativeMethods.IConnectionPointContainer cpc = (UnsafeNativeMethods.IConnectionPointContainer)source;

                    try {
                        Guid tmp = eventInterface.GUID;
                        if (cpc.FindConnectionPoint(ref tmp, out connectionPoint) != NativeMethods.S_OK) {
                            connectionPoint = null;
                        }
                    }
                    catch (Exception) {
                        connectionPoint = null;
                    }

                    if (connectionPoint == null) {
                        ex = new ArgumentException(SR.GetString(SR.ConnPointSourceIF, eventInterface.Name ));
                    }
                    else if (sink == null || !eventInterface.IsInstanceOfType(sink)) {
                        ex = new InvalidCastException(SR.GetString(SR.ConnPointSinkIF));
                    }
                    else {
                        int hr = connectionPoint.Advise(sink, ref cookie);
                        if (hr != S_OK) {
                            cookie = 0;
                            Marshal.ReleaseComObject(connectionPoint);
                            connectionPoint = null;
                            ex = new ExternalException(SR.GetString(SR.ConnPointAdviseFailed, eventInterface.Name, hr ));
                        }
                        else {
                            connected = true;
                        }
                    }
                }
                else {
                    ex = new InvalidCastException(SR.GetString(SR.ConnPointSourceIF, "IConnectionPointContainer"));
                }


                if (throwException && (connectionPoint == null || cookie == 0)) {
                    if (connectionPoint != null) {
                        Marshal.ReleaseComObject(connectionPoint);
                    }

                    if (ex == null) {
                        throw new ArgumentException(SR.GetString(SR.ConnPointCouldNotCreate, eventInterface.Name ));
                    }
                    else {
                        throw ex;
                    }
                }

                #if DEBUG
                new EnvironmentPermission(PermissionState.Unrestricted).Assert();
                try {
                    callStack = Environment.StackTrace;
                }
                finally {
                    System.Security.CodeAccessPermission.RevertAssert();
                }
                #endif
            }
Exemplo n.º 35
0
 static internal InvalidCastException InvalidCast(string error, Exception inner)
 {
     InvalidCastException e = new InvalidCastException(error, inner);
     return e;
 }
Exemplo n.º 36
0
        static internal Exception ParameterConversionFailed(object value, Type destType, Exception inner)
        {
            Debug.Assert(null != value, "null value on conversion failure");
            Debug.Assert(null != inner, "null inner on conversion failure");

            Exception e;
            string message = Res.GetString(Res.ADP_ParameterConversionFailed, value.GetType().Name, destType.Name);
            if (inner is ArgumentException)
            {
                e = new ArgumentException(message, inner);
            }
            else if (inner is FormatException)
            {
                e = new FormatException(message, inner);
            }
            else if (inner is InvalidCastException)
            {
                e = new InvalidCastException(message, inner);
            }
            else if (inner is OverflowException)
            {
                e = new OverflowException(message, inner);
            }
            else
            {
                e = inner;
            }
            return e;
        }
Exemplo n.º 37
0
        private static void FindMemberCastFailByIndex(ModelContext ctx, IDataReader dr, InvalidCastException ex)
        {
            var text = new StringBuilder();
            var ms   = ctx.Info.SimpleMembers;

            for (int i = 0; i < ms.Length; i++)
            {
                CheckMemberCast(ms[i], dr[i], text);
            }
            if (text.Length > 0)
            {
                throw new DataException(text.ToString(), ex);
            }
        }
Exemplo n.º 38
0
        public void SameType()
        {
            var expected = new InvalidCastException();

            Assert.IsAssignableFrom(typeof(InvalidCastException), expected);
        }
        private InvalidCastException _excepcion; //Tipo de excepcion que se genero.

        public CasteoNoCorrectoException(InvalidCastException excepcion, string mensaje)
        {
            _fecha     = DateTime.Now;
            _mensaje   = mensaje;
            _excepcion = excepcion;
        }
Exemplo n.º 40
0
 static internal InvalidCastException InvalidCast()
 {
     InvalidCastException e = new InvalidCastException();
     return e;
 }
Exemplo n.º 41
0
        /// <summary>
        /// This does a mapping from hr to the exception and also takes care of making default exception in case of classic COM as COMException.
        /// and in winrt and marshal APIs as Exception.
        /// </summary>
        /// <param name="errorCode"></param>
        /// <param name="message"></param>
        /// <param name="createCOMException"></param>
        /// <returns></returns>
        internal static Exception GetMappingExceptionForHR(int errorCode, string message, bool createCOMException, bool hasErrorInfo)
        {
            if (errorCode >= 0)
            {
                return(null);
            }

            Exception exception = null;

            bool shouldDisplayHR = false;

            switch (errorCode)
            {
            case __HResults.COR_E_NOTFINITENUMBER:     // NotFiniteNumberException
            case __HResults.COR_E_ARITHMETIC:
                exception = new ArithmeticException();
                break;

            case __HResults.COR_E_ARGUMENT:
            case unchecked ((int)0x800A01C1):
            case unchecked ((int)0x800A01C2):
            case __HResults.CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT:
                exception = new ArgumentException();

                if (errorCode != __HResults.COR_E_ARGUMENT)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.E_BOUNDS:
            case __HResults.COR_E_ARGUMENTOUTOFRANGE:
            case __HResults.ERROR_NO_UNICODE_TRANSLATION:
                exception = new ArgumentOutOfRangeException();

                if (errorCode != __HResults.COR_E_ARGUMENTOUTOFRANGE)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_ARRAYTYPEMISMATCH:
                exception = new ArrayTypeMismatchException();
                break;

            case __HResults.COR_E_BADIMAGEFORMAT:
            case __HResults.CLDB_E_FILE_OLDVER:
            case __HResults.CLDB_E_INDEX_NOTFOUND:
            case __HResults.CLDB_E_FILE_CORRUPT:
            case __HResults.COR_E_NEWER_RUNTIME:
            case __HResults.COR_E_ASSEMBLYEXPECTED:
            case __HResults.ERROR_BAD_EXE_FORMAT:
            case __HResults.ERROR_EXE_MARKED_INVALID:
            case __HResults.CORSEC_E_INVALID_IMAGE_FORMAT:
            case __HResults.ERROR_NOACCESS:
            case __HResults.ERROR_INVALID_ORDINAL:
            case __HResults.ERROR_INVALID_DLL:
            case __HResults.ERROR_FILE_CORRUPT:
            case __HResults.COR_E_LOADING_REFERENCE_ASSEMBLY:
            case __HResults.META_E_BAD_SIGNATURE:
                exception = new BadImageFormatException();

                // Always show HR for BadImageFormatException
                shouldDisplayHR = true;

                break;

            case __HResults.COR_E_CUSTOMATTRIBUTEFORMAT:
                exception = new FormatException();
                break;     // CustomAttributeFormatException

            case __HResults.COR_E_DATAMISALIGNED:
                exception = InteropExtensions.CreateDataMisalignedException(message);     // TODO: Do we need to add msg here?
                break;

            case __HResults.COR_E_DIVIDEBYZERO:
            case __HResults.CTL_E_DIVISIONBYZERO:
                exception = new DivideByZeroException();

                if (errorCode != __HResults.COR_E_DIVIDEBYZERO)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_DLLNOTFOUND:
#if ENABLE_WINRT
                exception = new DllNotFoundException();
#endif
                break;

            case __HResults.COR_E_DUPLICATEWAITOBJECT:
                exception = new ArgumentException();
                break;     // DuplicateWaitObjectException

            case __HResults.COR_E_ENDOFSTREAM:
            case unchecked ((int)0x800A003E):
                exception = new System.IO.EndOfStreamException();

                if (errorCode != __HResults.COR_E_ENDOFSTREAM)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_TYPEACCESS:     // TypeAccessException
            case __HResults.COR_E_ENTRYPOINTNOTFOUND:
                exception = new TypeLoadException();

                break;     // EntryPointNotFoundException

            case __HResults.COR_E_EXCEPTION:
                exception = new Exception();
                break;

            case __HResults.COR_E_DIRECTORYNOTFOUND:
            case __HResults.STG_E_PATHNOTFOUND:
            case __HResults.CTL_E_PATHNOTFOUND:
                exception = new System.IO.DirectoryNotFoundException();

                if (errorCode != __HResults.COR_E_DIRECTORYNOTFOUND)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_FILELOAD:
            case __HResults.FUSION_E_INVALID_PRIVATE_ASM_LOCATION:
            case __HResults.FUSION_E_SIGNATURE_CHECK_FAILED:
            case __HResults.FUSION_E_LOADFROM_BLOCKED:
            case __HResults.FUSION_E_CACHEFILE_FAILED:
            case __HResults.FUSION_E_ASM_MODULE_MISSING:
            case __HResults.FUSION_E_INVALID_NAME:
            case __HResults.FUSION_E_PRIVATE_ASM_DISALLOWED:
            case __HResults.FUSION_E_HOST_GAC_ASM_MISMATCH:
            case __HResults.COR_E_MODULE_HASH_CHECK_FAILED:
            case __HResults.FUSION_E_REF_DEF_MISMATCH:
            case __HResults.SECURITY_E_INCOMPATIBLE_SHARE:
            case __HResults.SECURITY_E_INCOMPATIBLE_EVIDENCE:
            case __HResults.SECURITY_E_UNVERIFIABLE:
            case __HResults.COR_E_FIXUPSINEXE:
            case __HResults.ERROR_TOO_MANY_OPEN_FILES:
            case __HResults.ERROR_SHARING_VIOLATION:
            case __HResults.ERROR_LOCK_VIOLATION:
            case __HResults.ERROR_OPEN_FAILED:
            case __HResults.ERROR_DISK_CORRUPT:
            case __HResults.ERROR_UNRECOGNIZED_VOLUME:
            case __HResults.ERROR_DLL_INIT_FAILED:
            case __HResults.FUSION_E_CODE_DOWNLOAD_DISABLED:
            case __HResults.CORSEC_E_MISSING_STRONGNAME:
            case __HResults.MSEE_E_ASSEMBLYLOADINPROGRESS:
            case __HResults.ERROR_FILE_INVALID:
                exception = new System.IO.FileLoadException();

                shouldDisplayHR = true;
                break;

            case __HResults.COR_E_PATHTOOLONG:
                exception = new System.IO.PathTooLongException();
                break;

            case __HResults.COR_E_IO:
            case __HResults.CTL_E_DEVICEIOERROR:
            case unchecked ((int)0x800A793C):
            case unchecked ((int)0x800A793D):
                exception = new System.IO.IOException();

                if (errorCode != __HResults.COR_E_IO)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.ERROR_FILE_NOT_FOUND:
            case __HResults.ERROR_MOD_NOT_FOUND:
            case __HResults.ERROR_INVALID_NAME:
            case __HResults.CTL_E_FILENOTFOUND:
            case __HResults.ERROR_BAD_NET_NAME:
            case __HResults.ERROR_BAD_NETPATH:
            case __HResults.ERROR_NOT_READY:
            case __HResults.ERROR_WRONG_TARGET_NAME:
            case __HResults.INET_E_UNKNOWN_PROTOCOL:
            case __HResults.INET_E_CONNECTION_TIMEOUT:
            case __HResults.INET_E_CANNOT_CONNECT:
            case __HResults.INET_E_RESOURCE_NOT_FOUND:
            case __HResults.INET_E_OBJECT_NOT_FOUND:
            case __HResults.INET_E_DOWNLOAD_FAILURE:
            case __HResults.INET_E_DATA_NOT_AVAILABLE:
            case __HResults.ERROR_DLL_NOT_FOUND:
            case __HResults.CLR_E_BIND_ASSEMBLY_VERSION_TOO_LOW:
            case __HResults.CLR_E_BIND_ASSEMBLY_PUBLIC_KEY_MISMATCH:
            case __HResults.CLR_E_BIND_ASSEMBLY_NOT_FOUND:
                exception = new System.IO.FileNotFoundException();

                shouldDisplayHR = true;
                break;

            case __HResults.COR_E_FORMAT:
                exception = new FormatException();
                break;

            case __HResults.COR_E_INDEXOUTOFRANGE:
            case unchecked ((int)0x800a0009):
                exception = new IndexOutOfRangeException();

                if (errorCode != __HResults.COR_E_INDEXOUTOFRANGE)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_INVALIDCAST:
                exception = new InvalidCastException();
                break;

            case __HResults.COR_E_INVALIDCOMOBJECT:
                exception = new InvalidComObjectException();
                break;

            case __HResults.COR_E_INVALIDOLEVARIANTTYPE:
                exception = new InvalidOleVariantTypeException();
                break;

            case __HResults.COR_E_INVALIDOPERATION:
            case __HResults.E_ILLEGAL_STATE_CHANGE:
            case __HResults.E_ILLEGAL_METHOD_CALL:
            case __HResults.E_ILLEGAL_DELEGATE_ASSIGNMENT:
            case __HResults.APPMODEL_ERROR_NO_PACKAGE:
                exception = new InvalidOperationException();

                if (errorCode != __HResults.COR_E_INVALIDOPERATION)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_MARSHALDIRECTIVE:
                exception = new MarshalDirectiveException();
                break;

            case __HResults.COR_E_METHODACCESS:            // MethodAccessException
            case __HResults.META_E_CA_FRIENDS_SN_REQUIRED: // MethodAccessException
            case __HResults.COR_E_FIELDACCESS:
            case __HResults.COR_E_MEMBERACCESS:
                exception = new MemberAccessException();

                if (errorCode != __HResults.COR_E_METHODACCESS)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_MISSINGFIELD:     // MissingFieldException
            case __HResults.COR_E_MISSINGMETHOD:    // MissingMethodException
            case __HResults.COR_E_MISSINGMEMBER:
            case unchecked ((int)0x800A01CD):
                exception = new MissingMemberException();
                break;

            case __HResults.COR_E_MISSINGMANIFESTRESOURCE:
                exception = new System.Resources.MissingManifestResourceException();
                break;

            case __HResults.COR_E_NOTSUPPORTED:
            case unchecked ((int)0x800A01B6):
            case unchecked ((int)0x800A01BD):
            case unchecked ((int)0x800A01CA):
            case unchecked ((int)0x800A01CB):
                exception = new NotSupportedException();

                if (errorCode != __HResults.COR_E_NOTSUPPORTED)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_NULLREFERENCE:
                exception = new NullReferenceException();
                break;

            case __HResults.COR_E_OBJECTDISPOSED:
            case __HResults.RO_E_CLOSED:
                // No default constructor
                exception = new ObjectDisposedException(String.Empty);
                break;

            case __HResults.COR_E_OPERATIONCANCELED:
#if ENABLE_WINRT
                exception = new OperationCanceledException();
#endif
                break;

            case __HResults.COR_E_OVERFLOW:
            case __HResults.CTL_E_OVERFLOW:
                exception = new OverflowException();
                break;

            case __HResults.COR_E_PLATFORMNOTSUPPORTED:
                exception = new PlatformNotSupportedException(message);
                break;

            case __HResults.COR_E_RANK:
                exception = new RankException();
                break;

            case __HResults.COR_E_REFLECTIONTYPELOAD:
#if ENABLE_WINRT
                exception = new System.Reflection.ReflectionTypeLoadException(null, null);
#endif
                break;

            case __HResults.COR_E_SECURITY:
            case __HResults.CORSEC_E_INVALID_STRONGNAME:
            case __HResults.CTL_E_PERMISSIONDENIED:
            case unchecked ((int)0x800A01A3):
            case __HResults.CORSEC_E_INVALID_PUBLICKEY:
            case __HResults.CORSEC_E_SIGNATURE_MISMATCH:
                exception = new System.Security.SecurityException();
                break;

            case __HResults.COR_E_SAFEARRAYRANKMISMATCH:
                exception = new SafeArrayRankMismatchException();
                break;

            case __HResults.COR_E_SAFEARRAYTYPEMISMATCH:
                exception = new SafeArrayTypeMismatchException();
                break;

            case __HResults.COR_E_SERIALIZATION:
                exception = ConstructExceptionUsingReflection(
                    "System.Runtime.Serialization.SerializationException, System.Runtime.Serialization.Primitives, Version=4.0.0.0",
                    message);
                break;

            case __HResults.COR_E_SYNCHRONIZATIONLOCK:
                exception = new System.Threading.SynchronizationLockException();
                break;

            case __HResults.COR_E_TARGETINVOCATION:
                exception = new System.Reflection.TargetInvocationException(null);
                break;

            case __HResults.COR_E_TARGETPARAMCOUNT:
                exception = new System.Reflection.TargetParameterCountException();
                break;

            case __HResults.COR_E_TYPEINITIALIZATION:
                exception = InteropExtensions.CreateTypeInitializationException(message);
                break;

            case __HResults.COR_E_TYPELOAD:
            case __HResults.RO_E_METADATA_NAME_NOT_FOUND:
            case __HResults.CLR_E_BIND_TYPE_NOT_FOUND:
                exception = new TypeLoadException();

                if (errorCode != __HResults.COR_E_TYPELOAD)
                {
                    shouldDisplayHR = true;
                }

                break;

            case __HResults.COR_E_UNAUTHORIZEDACCESS:
            case __HResults.CTL_E_PATHFILEACCESSERROR:
            case unchecked ((int)0x800A014F):
                exception = new UnauthorizedAccessException();

                shouldDisplayHR = true;

                break;

            case __HResults.COR_E_VERIFICATION:
                exception = new System.Security.VerificationException();
                break;

            case __HResults.E_NOTIMPL:
                exception = new NotImplementedException();
                break;

            case __HResults.E_OUTOFMEMORY:
            case __HResults.CTL_E_OUTOFMEMORY:
            case unchecked ((int)0x800A7919):
                exception = new OutOfMemoryException();

                if (errorCode != __HResults.E_OUTOFMEMORY)
                {
                    shouldDisplayHR = true;
                }

                break;

#if ENABLE_WINRT
            case __HResults.E_XAMLPARSEFAILED:
                exception = ConstructExceptionUsingReflection(
                    "Windows.UI.Xaml.Markup.XamlParseException, System.Runtime.WindowsRuntime.UI.Xaml, Version=4.0.0.0",
                    message);
                break;

            case __HResults.E_ELEMENTNOTAVAILABLE:
                exception = ConstructExceptionUsingReflection(
                    "Windows.UI.Xaml.Automation.ElementNotAvailableException, System.Runtime.WindowsRuntime.UI.Xaml, Version=4.0.0.0",
                    message);
                break;

            case __HResults.E_ELEMENTNOTENABLED:
                exception = ConstructExceptionUsingReflection(
                    "Windows.UI.Xaml.Automation.ElementNotEnabledException, System.Runtime.WindowsRuntime.UI.Xaml, Version=4.0.0.0",
                    message);
                break;

            case __HResults.E_LAYOUTCYCLE:
                exception = ConstructExceptionUsingReflection(
                    "Windows.UI.Xaml.LayoutCycleException, System.Runtime.WindowsRuntime.UI.Xaml, Version=4.0.0.0",
                    message);
                break;
#endif // ENABLE_WINRT
            case __HResults.COR_E_AMBIGUOUSMATCH:     // AmbiguousMatchException
            case __HResults.COR_E_APPLICATION:     // ApplicationException
            case __HResults.COR_E_APPDOMAINUNLOADED:          // AppDomainUnloadedException
            case __HResults.COR_E_CANNOTUNLOADAPPDOMAIN:      // CannotUnloadAppDomainException
            case __HResults.COR_E_CODECONTRACTFAILED:         // ContractException
            case __HResults.COR_E_CONTEXTMARSHAL:             // ContextMarshalException
            case __HResults.CORSEC_E_CRYPTO:                  // CryptographicException
            case __HResults.CORSEC_E_CRYPTO_UNEX_OPER:        // CryptographicUnexpectedOperationException
            case __HResults.COR_E_EXECUTIONENGINE:            // ExecutionEngineException
            case __HResults.COR_E_INSUFFICIENTEXECUTIONSTACK: // InsufficientExecutionStackException
            case __HResults.COR_E_INVALIDFILTERCRITERIA:      // InvalidFilterCriteriaException
            case __HResults.COR_E_INVALIDPROGRAM:             // InvalidProgramException
            case __HResults.COR_E_MULTICASTNOTSUPPORTED:      // MulticastNotSupportedException
            case __HResults.COR_E_REMOTING:                   // RemotingException
            case __HResults.COR_E_RUNTIMEWRAPPED:             // RuntimeWrappedException
            case __HResults.COR_E_SERVER:                     // ServerException
            case __HResults.COR_E_STACKOVERFLOW:              // StackOverflowException
            case __HResults.CTL_E_OUTOFSTACKSPACE:            // StackOverflowException
            case __HResults.COR_E_SYSTEM:                     // SystemException
            case __HResults.COR_E_TARGET:                     // TargetException
            case __HResults.COR_E_THREADABORTED:              // TargetException
            case __HResults.COR_E_THREADINTERRUPTED:          // ThreadInterruptedException
            case __HResults.COR_E_THREADSTATE:                // ThreadStateException
            case __HResults.COR_E_THREADSTART:                // ThreadStartException
            case __HResults.COR_E_TYPEUNLOADED:               // TypeUnloadedException
            case __HResults.CORSEC_E_POLICY_EXCEPTION:        // PolicyException
            case __HResults.CORSEC_E_NO_EXEC_PERM:            // PolicyException
            case __HResults.CORSEC_E_MIN_GRANT_FAIL:          // PolicyException
            case __HResults.CORSEC_E_XMLSYNTAX:               // XmlSyntaxException
            case __HResults.ISS_E_ALLOC_TOO_LARGE:            // IsolatedStorageException
            case __HResults.ISS_E_BLOCK_SIZE_TOO_SMALL:       // IsolatedStorageException
            case __HResults.ISS_E_CALLER:                     // IsolatedStorageException
            case __HResults.ISS_E_CORRUPTED_STORE_FILE:       // IsolatedStorageException
            case __HResults.ISS_E_CREATE_DIR:                 // IsolatedStorageException
            case __HResults.ISS_E_CREATE_MUTEX:               // IsolatedStorageException
            case __HResults.ISS_E_DEPRECATE:                  // IsolatedStorageException
            case __HResults.ISS_E_FILE_NOT_MAPPED:            // IsolatedStorageException
            case __HResults.ISS_E_FILE_WRITE:                 // IsolatedStorageException
            case __HResults.ISS_E_GET_FILE_SIZE:              // IsolatedStorageException
            case __HResults.ISS_E_ISOSTORE:                   // IsolatedStorageException
            case __HResults.ISS_E_LOCK_FAILED:                // IsolatedStorageException
            case __HResults.ISS_E_MACHINE:                    // IsolatedStorageException
            case __HResults.ISS_E_MACHINE_DACL:               // IsolatedStorageException
            case __HResults.ISS_E_MAP_VIEW_OF_FILE:           // IsolatedStorageException
            case __HResults.ISS_E_OPEN_FILE_MAPPING:          // IsolatedStorageException
            case __HResults.ISS_E_OPEN_STORE_FILE:            // IsolatedStorageException
            case __HResults.ISS_E_PATH_LENGTH:                // IsolatedStorageException
            case __HResults.ISS_E_SET_FILE_POINTER:           // IsolatedStorageException
            case __HResults.ISS_E_STORE_NOT_OPEN:             // IsolatedStorageException
            case __HResults.ISS_E_STORE_VERSION:              // IsolatedStorageException
            case __HResults.ISS_E_TABLE_ROW_NOT_FOUND:        // IsolatedStorageException
            case __HResults.ISS_E_USAGE_WILL_EXCEED_QUOTA:    // IsolatedStorageException
            case __HResults.E_FAIL:
            default:
                break;
            }

            if (exception == null)
            {
                if (createCOMException)
                {
                    exception = new COMException();
                    if (errorCode != __HResults.E_FAIL)
                    {
                        shouldDisplayHR = true;
                    }
                }
                else
                {
                    exception = new Exception();
                    if (errorCode != __HResults.COR_E_EXCEPTION)
                    {
                        shouldDisplayHR = true;
                    }
                }
            }

            bool shouldConstructMessage = false;
            if (hasErrorInfo)
            {
                // If there is a IErrorInfo/IRestrictedErrorInfo, only construct a new error message if
                // the message is not available and do not use the shouldDisplayHR setting
                if (message == null)
                {
                    shouldConstructMessage = true;
                }
            }
            else
            {
                // If there is no IErrorInfo, use the shouldDisplayHR setting from the big switch/case above
                shouldConstructMessage = shouldDisplayHR;
            }

            if (shouldConstructMessage)
            {
                //
                // Append the HR into error message, just in case the app wants to look at the HR in
                // message to determine behavior.  We didn't expose HResult property until v4.5 and
                // GetHRFromException has side effects so probably Message was their only choice.
                // This behavior is probably not exactly the same as in desktop but it is fine to append
                // more message at the end. In any case, having the HR in the error message are helpful
                // to developers.
                // This makes sure:
                // 1. We always have a HR 0xNNNNNNNN in the message
                // 2. Put in a nice "Exception thrown from HRESULT" message if we can
                // 3. Wrap it in () if there is an existing message
                //

                // TODO: Add Symbolic Name into Messaage, convert 0x80020006 to DISP_E_UNKNOWNNAME
                string hrMessage = String.Format("{0} 0x{1:X}", SR.Excep_FromHResult, errorCode);

                message = ExternalInterop.GetMessage(errorCode);

                // Always make sure we have at least the HRESULT part in retail build or when the message
                // is empty.
                if (message == null)
                {
                    message = hrMessage;
                }
                else
                {
                    message = message + " (" + hrMessage + ")";
                }
            }

            if (message != null)
            {
                // Set message explicitly rather than calling constructor because certain ctors would append a
                // prefix to the message and that is not what we want
                InteropExtensions.SetExceptionMessage(exception, message);
            }

            InteropExtensions.SetExceptionErrorCode(exception, errorCode);

            return(exception);
        }
Exemplo n.º 42
0
 public void IsAssignableFrom_SameType()
 {
     InvalidCastException expected = new InvalidCastException();
     Assert.IsAssignableFrom(typeof(InvalidCastException), expected);
     Assert.IsAssignableFrom<InvalidCastException>(expected);
 }
Exemplo n.º 43
0
        public void UnmatchedType()
        {
            InvalidCastException expected = new InvalidCastException();

            Assert.IsNotType <Exception>(expected);
        }