//*************************************************************************
        //  Method: DataGridViewRowToEmailParticipantCriteria()
        //
        /// <summary>
        /// Creates a <see cref="EmailParticipantCriteria" /> object from the
        /// contents of a DataGridViewRow from the dgvParticipants DataGridView.
        /// </summary>
        ///
        /// <returns>
        /// A <see cref="EmailParticipantCriteria" /> object.  Important: The
        /// DataGridViewRow is not validated and the returned object may contain
        /// invalid data.
        /// </returns>
        //*************************************************************************
        protected EmailParticipantCriteria DataGridViewRowToEmailParticipantCriteria(
            DataGridViewRow oRow
            )
        {
            Debug.Assert(oRow != null);
            AssertValid();

            EmailParticipantCriteria oEmailParticipantCriteria =
            new EmailParticipantCriteria();

            String sParticipant =
            (String)oRow.Cells[this.colParticipant.Name].Value;

            if ( !String.IsNullOrEmpty(sParticipant) )
            {
            // Trim the participant string.

            sParticipant = sParticipant.Trim();
            oRow.Cells[this.colParticipant.Name].Value = sParticipant;
            }

            if ( !String.IsNullOrEmpty(sParticipant) )
            {
            sParticipant = ParticipantToAnalyzer(sParticipant);
            }

            oEmailParticipantCriteria.Participant = sParticipant;

            IncludedIn eIncludedIn = IncludedIn.None;

            if ( DataGridViewCheckBoxCellIsChecked(oRow, this.colFrom.Name) )
            {
            eIncludedIn |= IncludedIn.From;
            }

            if ( DataGridViewCheckBoxCellIsChecked(oRow, this.colTo.Name) )
            {
            eIncludedIn |= IncludedIn.To;
            }

            if ( DataGridViewCheckBoxCellIsChecked(oRow, this.colCc.Name) )
            {
            eIncludedIn |= IncludedIn.Cc;
            }

            if ( DataGridViewCheckBoxCellIsChecked(oRow, this.colBcc.Name) )
            {
            eIncludedIn |= IncludedIn.Bcc;
            }

            oEmailParticipantCriteria.IncludedIn = eIncludedIn;

            return (oEmailParticipantCriteria);
        }
예제 #2
0
        //*************************************************************************
        //  Method: AnalyzeEmailNetworkInternal()
        //
        /// <summary>
        /// Analyzes the part of a user's email social network that satisfies
        /// specified criteria.
        /// </summary>
        ///
        /// <param name="participantsCriteria">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="startTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="endTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="subjectText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="bodyText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="folder">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="minimumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="maximumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="attachmentFilter">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="hasCc">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="hasBcc">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="isReplyFromParticipant1">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="useCcForEdgeWeights">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="useBccForEdgeWeights">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="backgroundWorker">
        /// A BackgroundWorker object if this method is being called
        /// asynchronously, or null if it is being called synchronously.
        /// </param>
        ///
        /// <param name="doWorkEventArgs">
        /// A DoWorkEventArgs object if this method is being called
        /// asynchronously, or null if it is being called synchronously.
        /// </param>
        ///
        /// <returns>
        /// See AnalyzeEmailNetwork().
        /// </returns>
        //*************************************************************************
        protected EmailParticipantPair[] AnalyzeEmailNetworkInternal(
            EmailParticipantCriteria [] participantsCriteria,
            Nullable<DateTime> startTime,
            Nullable<DateTime> endTime,
            String subjectText,
            String bodyText,
            String folder,
            Nullable<Int64> minimumSize,
            Nullable<Int64> maximumSize,
            Nullable<AttachmentFilter> attachmentFilter,
            Nullable<Boolean> hasCc,
            Nullable<Boolean> hasBcc,
            Nullable<Boolean> isReplyFromParticipant1,
            Boolean useCcForEdgeWeights,
            Boolean useBccForEdgeWeights,
            BackgroundWorker backgroundWorker,
            DoWorkEventArgs doWorkEventArgs
            )
        {
            CheckAnalyzeMethodArguments(participantsCriteria, startTime, endTime,
            subjectText, bodyText, folder, minimumSize, maximumSize,
            attachmentFilter, isReplyFromParticipant1);

            Debug.Assert(backgroundWorker == null || doWorkEventArgs != null);

            AssertValid();

            String sQuery = CreateQuery(participantsCriteria, startTime, endTime,
            subjectText, bodyText, folder, minimumSize, maximumSize,
            attachmentFilter, hasCc, hasBcc, isReplyFromParticipant1);

            OleDbDataReader oDataReader = GetDataReader(sQuery);

            EmailParticipantPair [] aoEmailParticipantPairs = null;

            try
            {
            aoEmailParticipantPairs = AnalyzeEmailNetworkInternal(
                oDataReader, useCcForEdgeWeights, useBccForEdgeWeights,
                backgroundWorker, doWorkEventArgs);
            }
            finally
            {
            oDataReader.Close();
            }

            return (aoEmailParticipantPairs);
        }
예제 #3
0
        //*************************************************************************
        //  Method: AnalyzeEmailNetworkAsync()
        //
        /// <summary>
        /// Asynchronously analyzes the part of a user's email social network that
        /// satisfies specified criteria.
        /// </summary>
        ///
        /// <param name="participantsCriteria">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="startTime">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="endTime">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="subjectText">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="bodyText">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="folder">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="minimumSize">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="maximumSize">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="attachmentFilter">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="hasCc">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="hasBcc">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="isReplyFromParticipant1">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="useCcForEdgeWeights">
        /// See the synchronous method.
        /// </param>
        ///
        /// <param name="useBccForEdgeWeights">
        /// See the synchronous method.
        /// </param>
        ///
        /// <remarks>
        /// When the analysis completes, the <see cref="AnalysisCompleted" /> event
        /// fires.  The <see cref="RunWorkerCompletedEventArgs.Result" /> property
        /// will return an array of zero or more <see cref="EmailParticipantPair" />
        /// objects, one for each pair of participants in the user's email social
        /// network that satisfy the specified criteria.  The property is never
        /// null.
        ///
        /// <para>
        /// To cancel the analysis, call <see cref="CancelAsync" />.
        /// </para>
        ///
        /// </remarks>
        //*************************************************************************
        public void AnalyzeEmailNetworkAsync(
            EmailParticipantCriteria [] participantsCriteria,
            Nullable<DateTime> startTime,
            Nullable<DateTime> endTime,
            String subjectText,
            String bodyText,
            String folder,
            Nullable<Int64> minimumSize,
            Nullable<Int64> maximumSize,
            Nullable<AttachmentFilter> attachmentFilter,
            Nullable<Boolean> hasCc,
            Nullable<Boolean> hasBcc,
            Nullable<Boolean> isReplyFromParticipant1,
            Boolean useCcForEdgeWeights,
            Boolean useBccForEdgeWeights
            )
        {
            AssertValid();

            const String MethodName = "AnalyzeEmailNetworkAsync";

            if (this.IsBusy)
            {
            throw new InvalidOperationException( String.Format(

                "{0}:{1}: An asynchronous operation is already in progress."
                ,
                this.ClassName,
                MethodName
                ) );
            }

            // Wrap the arguments in an object that can be passed to
            // BackgroundWorker.RunWorkerAsync().

            AnalyzeEmailNetworkAsyncArgs oAnalyzeEmailNetworkAsyncArgs =
            new AnalyzeEmailNetworkAsyncArgs();

            oAnalyzeEmailNetworkAsyncArgs.ParticipantsCriteria =
            participantsCriteria;

            oAnalyzeEmailNetworkAsyncArgs.StartTime = startTime;
            oAnalyzeEmailNetworkAsyncArgs.EndTime = endTime;
            oAnalyzeEmailNetworkAsyncArgs.SubjectText = subjectText;
            oAnalyzeEmailNetworkAsyncArgs.BodyText = bodyText;
            oAnalyzeEmailNetworkAsyncArgs.Folder = folder;
            oAnalyzeEmailNetworkAsyncArgs.MinimumSize = minimumSize;
            oAnalyzeEmailNetworkAsyncArgs.MaximumSize = maximumSize;
            oAnalyzeEmailNetworkAsyncArgs.AttachmentFilter = attachmentFilter;
            oAnalyzeEmailNetworkAsyncArgs.HasCc = hasCc;
            oAnalyzeEmailNetworkAsyncArgs.HasBcc = hasBcc;

            oAnalyzeEmailNetworkAsyncArgs.IsReplyFromParticipant1 =
            isReplyFromParticipant1;

            oAnalyzeEmailNetworkAsyncArgs.UseCcForEdgeWeights =
            useCcForEdgeWeights;

            oAnalyzeEmailNetworkAsyncArgs.UseBccForEdgeWeights =
            useBccForEdgeWeights;

            // Create a BackgroundWorker and handle its events.

            m_oBackgroundWorker = new BackgroundWorker();

            m_oBackgroundWorker.WorkerSupportsCancellation = true;

            m_oBackgroundWorker.DoWork += new DoWorkEventHandler(
            BackgroundWorker_DoWork);

            m_oBackgroundWorker.RunWorkerCompleted +=
            new RunWorkerCompletedEventHandler(
                BackgroundWorker_RunWorkerCompleted);

            m_oBackgroundWorker.RunWorkerAsync(oAnalyzeEmailNetworkAsyncArgs);
        }
예제 #4
0
        //*************************************************************************
        //  Method: AnalyzeEmailNetwork()
        //
        /// <summary>
        /// Synchronously analyzes the part of a user's email social network that
        /// satisfies specified criteria.
        /// </summary>
        ///
        /// <param name="participantsCriteria">
        /// An array of <see cref="EmailParticipantCriteria" /> objects, one for
        /// each participant to filter on, or null to not filter on participants.
        /// For each element in the array, <see
        /// cref="EmailParticipantCriteria.Participant" /> must be specified, but
        /// <see cref="EmailParticipantCriteria.IncludedIn" /> can be <see
        /// cref="IncludedIn.None" />.
        /// </param>
        ///
        /// <param name="startTime">
        /// If specified, only emails sent on or after the specified time are
        /// included in the aggregated results.  Use null to specify "no start
        /// time."
        /// </param>
        ///
        /// <param name="endTime">
        /// If specified, only emails sent on or before the specified time are
        /// included in the aggregated results.  Use null to specify "no end time."
        /// </param>
        ///
        /// <param name="subjectText">
        /// Subject text to filter on, or null to not filter on subject text.
        /// Can't be an empty string.  If specified, only emails that include the
        /// specified subject text are included in the aggregated results.
        /// </param>
        ///
        /// <param name="bodyText">
        /// Body text to filter on, or null to not filter on body text.  Can't be
        /// an empty string.  If specified, only emails that include the specified
        /// body text are included in the aggregated results.
        /// </param>
        ///
        /// <param name="folder">
        /// Email folder to filter on, or null to not filter on the email folder.
        /// Can't be an empty string.  If specified, only emails in the specified
        /// folder are included in the aggregated results.  Sample: "Inbox".
        /// </param>
        ///
        /// <param name="minimumSize">
        /// If specified, only emails that have a size greater than or equal to the
        /// specified value are included in the aggregated results.
        /// </param>
        ///
        /// <param name="maximumSize">
        /// If specified, only emails that have a size less than or equal to the
        /// specified value are included in the aggregated results.
        /// </param>
        ///
        /// <param name="attachmentFilter">
        /// If not null, specifies how attachments are used to determine which
        /// emails are included in the aggregated results.  Use null to specify
        /// "don't care."
        /// </param>
        ///
        /// <param name="hasCc">
        /// If specified, only emails that have or don't have a Cc line are
        /// included in the aggregated results.  Use null to specify "don't care."
        /// </param>
        ///
        /// <param name="hasBcc">
        /// If specified, only emails that have or don't have a Bcc line are
        /// included in the aggregated results.  Use null to specify "don't care."
        /// </param>
        ///
        /// <param name="isReplyFromParticipant1">
        /// If specified, only emails that are or are not replies from <paramref
        /// name="participant1" /> are included in the aggregated results.
        /// Use null to specify "don't care."
        ///
        /// <para>
        /// [IMPORTANT NOTE: As of April 2008, the System.Message.IsFwdOrReply
        /// message property needed to implement this is always null.  Specifying
        /// true or false for this parameter will always return an empty array.
        /// The parameter is retained in case the missing property is fixed in a
        /// future version of Windows Desktop Search.]
        /// </para>
        ///
        /// </param>
        ///
        /// <param name="useCcForEdgeWeights">
        /// If true, an edge weight of one is assigned to the sender and each
        /// participant on the Cc line.  (An edge weight of one is always assigned
        /// to the sender and each participant on the To line.)
        /// </param>
        ///
        /// <param name="useBccForEdgeWeights">
        /// If true, an edge weight of one is assigned to the sender and each
        /// participant on the Bcc line.  (An edge weight of one is always assigned
        /// to the sender and each participant on the To line.)
        /// </param>
        ///
        /// <returns>
        /// An array of zero or more <see cref="EmailParticipantPair" /> objects,
        /// one for each pair of participants in the user's email social network
        /// that satisfy the specified criteria.  The return value is never null.
        /// </returns>
        ///
        /// <remarks>
        /// This overload does the same thing as the <see
        /// cref="AnalyzeEmailNetwork()" /> overload, but only those emails that
        /// match the specified criteria are aggregated.
        /// </remarks>
        //*************************************************************************
        public EmailParticipantPair[] AnalyzeEmailNetwork(
            EmailParticipantCriteria [] participantsCriteria,
            Nullable<DateTime> startTime,
            Nullable<DateTime> endTime,
            String subjectText,
            String bodyText,
            String folder,
            Nullable<Int64> minimumSize,
            Nullable<Int64> maximumSize,
            Nullable<AttachmentFilter> attachmentFilter,
            Nullable<Boolean> hasCc,
            Nullable<Boolean> hasBcc,
            Nullable<Boolean> isReplyFromParticipant1,
            Boolean useCcForEdgeWeights,
            Boolean useBccForEdgeWeights
            )
        {
            AssertValid();

            return ( AnalyzeEmailNetworkInternal(participantsCriteria, startTime,
            endTime, subjectText, bodyText, folder, minimumSize, maximumSize,
            attachmentFilter, hasCc, hasBcc, isReplyFromParticipant1,
            useCcForEdgeWeights, useBccForEdgeWeights, null, null) );
        }
예제 #5
0
        //*************************************************************************
        //  Method: CreateQuery()
        //
        /// <summary>
        /// Creates a query that uses specified criteria.
        /// </summary>
        ///
        /// <param name="participantsCriteria">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="startTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="endTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="subjectText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="bodyText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="folder">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="minimumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="maximumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="attachmentFilter">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="hasCc">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="hasBcc">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="isReplyFromParticipant1">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <returns>
        /// A query that uses the specified criteria.
        /// </returns>
        //*************************************************************************
        protected String CreateQuery(
            EmailParticipantCriteria [] participantsCriteria,
            Nullable<DateTime> startTime,
            Nullable<DateTime> endTime,
            String subjectText,
            String bodyText,
            String folder,
            Nullable<Int64> minimumSize,
            Nullable<Int64> maximumSize,
            Nullable<AttachmentFilter> attachmentFilter,
            Nullable<Boolean> hasCc,
            Nullable<Boolean> hasBcc,
            Nullable<Boolean> isReplyFromParticipant1
            )
        {
            AssertValid();

            StringBuilder oStringBuilder = new StringBuilder();
            oStringBuilder.Append(BaseQuery);

            String sEscapedFirstParticipant = null;
            Int32 i = 0;

            StringBuilder oParticipantCriteriaStringBuilder =
            new StringBuilder();

            if (participantsCriteria != null)
            {
            foreach (EmailParticipantCriteria oParticipantCriteria in
                participantsCriteria)
            {
                String sEscapedParticipant =
                    EscapeStringForContains(oParticipantCriteria.Participant);

                Debug.Assert( !String.IsNullOrEmpty(sEscapedParticipant) );

                if (i == 0)
                {
                    sEscapedFirstParticipant = sEscapedParticipant;
                }

                i++;

                IncludedIn eIncludedIn = oParticipantCriteria.IncludedIn;

                if (eIncludedIn == IncludedIn.None)
                {
                    // Skip this one.

                    continue;
                }

                if (oParticipantCriteriaStringBuilder.Length > 0)
                {
                    // The participants are ORed together.

                    oParticipantCriteriaStringBuilder.Append(" OR ");
                }

                // This part of the query will look like this, in pseudocode:
                //
                // ( Contains(To, Participant)
                // OR Contains(From, Participant) OR Contains(Cc, Participant)
                // OR Contains(Bcc, Participant) )

                // Open the outer clause.

                oParticipantCriteriaStringBuilder.Append("(");

                // Append a clause for each IncludedIn flag.

                Boolean bParticipantClauseAppended = false;

                AppendParticipantClauseToQuery(sEscapedParticipant,
                    eIncludedIn, IncludedIn.From,
                    oParticipantCriteriaStringBuilder,
                    ref bParticipantClauseAppended);

                AppendParticipantClauseToQuery(sEscapedParticipant,
                    eIncludedIn, IncludedIn.To,
                    oParticipantCriteriaStringBuilder,
                    ref bParticipantClauseAppended);

                AppendParticipantClauseToQuery(sEscapedParticipant,
                    eIncludedIn, IncludedIn.Cc,
                    oParticipantCriteriaStringBuilder,
                    ref bParticipantClauseAppended);

                AppendParticipantClauseToQuery(sEscapedParticipant,
                    eIncludedIn, IncludedIn.Bcc,
                    oParticipantCriteriaStringBuilder,
                    ref bParticipantClauseAppended);

                // Close the outer clause.

                oParticipantCriteriaStringBuilder.Append(")");
            }

            if (oParticipantCriteriaStringBuilder.Length > 0)
            {
                oStringBuilder.AppendFormat(

                    " AND ({0}) "
                    ,
                    oParticipantCriteriaStringBuilder
                    );
            }
            }

            const String DateSentClause =
            " AND System.Message.DateSent {0} '{1}'"
            ;

            if (startTime.HasValue)
            {
            oStringBuilder.AppendFormat(

                DateSentClause
                ,
                ">=",
                FormatTime(startTime.Value)
                );
            }

            if (endTime.HasValue)
            {
            oStringBuilder.AppendFormat(

                DateSentClause
                ,
                "<=",
                FormatTime(endTime.Value)
                );
            }

            if ( !String.IsNullOrEmpty(subjectText) )
            {
            // Important note:
            //
            // System.Subject works for the subject on Vista with its original
            // search engine, and with Windows Desktop Search 4.0.  On XP with
            // Windows.Desktop.Search, however, System.Subject does not work.
            // System.Title works in Vista/WDS4.0 and XP/WDS4.0.  (It has not
            // yet been tested on Vista with its original search engine).

            oStringBuilder.AppendFormat(

                " AND Contains(System.Title, '\"{0}\"')"
                ,
                EscapeStringForContains(subjectText)
                );
            }

            if ( !String.IsNullOrEmpty(bodyText) )
            {
            oStringBuilder.AppendFormat(

                " AND Contains ('\"{0}\"')"
                ,
                EscapeStringForContains(bodyText)
                );
            }

            if ( !String.IsNullOrEmpty(folder) )
            {
            oStringBuilder.AppendFormat(

                " AND System.ItemFolderPathDisplay = '{0}'"
                ,
                EscapeStringForEquals(folder)
                );
            }

            if (minimumSize.HasValue)
            {
            oStringBuilder.AppendFormat(

                " AND System.Size >= {0}"
                ,
                minimumSize.Value
                );
            }

            if (maximumSize.HasValue)
            {
            oStringBuilder.AppendFormat(

                " AND System.Size <= {0}"
                ,
                maximumSize.Value
                );
            }

            if (attachmentFilter.HasValue)
            {
            oStringBuilder.AppendFormat(

                " AND System.Message.HasAttachments = {0}"
                ,
                attachmentFilter.Value == AttachmentFilter.NoAttachment ?
                    "FALSE" : "TRUE"
                );

            if (attachmentFilter.Value ==
                AttachmentFilter.HasAttachmentFromParticipant1)
            {
                Debug.Assert( !String.IsNullOrEmpty(sEscapedFirstParticipant) );

                oStringBuilder.AppendFormat(

                    " AND Contains(System.Message.FromAddress, '\"{0}\"')"
                    ,
                    sEscapedFirstParticipant
                    );
            }
            }

            if (hasCc.HasValue)
            {
            oStringBuilder.AppendFormat(

                " AND System.Message.CcAddress IS {0} NULL"
                ,
                hasCc.Value ? "NOT": String.Empty
                );
            }

            if (hasBcc.HasValue)
            {
            oStringBuilder.AppendFormat(

                " AND System.Message.BccAddress IS {0} NULL"
                ,
                hasBcc.Value ? "NOT": String.Empty
                );
            }

            if (isReplyFromParticipant1.HasValue)
            {
            // IMPORTANT NOTE: As of April 2008, the
            // System.Message.IsFwdOrReply message property needed to implement
            // this is always null, so specifying a value here will always
            // return an empty recordset.
            //
            // Note: System.Message.IsFwdOrReply is an Int32, not a Boolean.
            // The documentation doesn't indicate what the possible values are.
            // I'm assuming that 1 means true and 0 means false.

            oStringBuilder.AppendFormat(

                " AND ( System.Message.IsFwdOrReply = {0} AND"
                + " Contains(System.Message.FromAddress, '\"{1}\"') )"
                ,
                isReplyFromParticipant1.Value ? 1 : 0,
                sEscapedFirstParticipant
                );
            }

            return ( oStringBuilder.ToString() );
        }
예제 #6
0
        //*************************************************************************
        //  Method: CheckAnalyzeMethodArguments()
        //
        /// <summary>
        /// Checks the arguments passed to AnalyzeEmailNetwork().
        /// </summary>
        ///
        /// <param name="participantsCriteria">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="startTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="endTime">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="subjectText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="bodyText">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="folder">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="minimumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="maximumSize">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="attachmentFilter">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <param name="isReplyFromParticipant1">
        /// See AnalyzeEmailNetwork().
        /// </param>
        ///
        /// <remarks>
        /// This method throws an exception if any arguments are invalid.
        /// </remarks>
        //*************************************************************************
        protected void CheckAnalyzeMethodArguments(
            EmailParticipantCriteria [] participantsCriteria,
            Nullable<DateTime> startTime,
            Nullable<DateTime> endTime,
            String subjectText,
            String bodyText,
            String folder,
            Nullable<Int64> minimumSize,
            Nullable<Int64> maximumSize,
            Nullable<AttachmentFilter> attachmentFilter,
            Nullable<Boolean> isReplyFromParticipant1
            )
        {
            AssertValid();

            ArgumentChecker oArgumentChecker = this.ArgumentChecker;

            Boolean bHasFirstParticipant = false;

            if (participantsCriteria != null)
            {
            foreach (EmailParticipantCriteria participantCriteria in
                participantsCriteria)
            {
                if ( String.IsNullOrEmpty(participantCriteria.Participant) )
                {
                    oArgumentChecker.ThrowArgumentException(AnalyzeMethodName,
                        "participantsCriteria",
                        "An email address wasn't specified.",
                        null
                        );
                }

                bHasFirstParticipant = true;
            }
            }

            if (startTime.HasValue && endTime.HasValue &&
            endTime.Value < startTime.Value)
            {
            oArgumentChecker.ThrowArgumentException(AnalyzeMethodName,
                "endTime",

                "The end time must be greater than or equal to the start"
                + " time.",

                null
                );
            }

            CheckAnalyzeMethodArgument(subjectText, "subjectText");
            CheckAnalyzeMethodArgument(bodyText, "bodyText");
            CheckAnalyzeMethodArgument(folder, "folder");

            if (minimumSize.HasValue)
            {
            oArgumentChecker.CheckArgumentPositive(
                AnalyzeMethodName, "minimumSize", minimumSize.Value);
            }

            if (maximumSize.HasValue)
            {
            oArgumentChecker.CheckArgumentPositive(
                AnalyzeMethodName, "maximumSize", maximumSize.Value);
            }

            if (minimumSize.HasValue && maximumSize.HasValue &&
            maximumSize.Value < minimumSize.Value)
            {
            oArgumentChecker.ThrowArgumentException(AnalyzeMethodName,
                "maximumSize",

                "maximumSize must be greater than or equal to"
                + " minimumSize."
                ,
                null
                );
            }

            if (attachmentFilter.HasValue &&
            attachmentFilter.Value ==
                AttachmentFilter.HasAttachmentFromParticipant1
            && !bHasFirstParticipant)
            {
            oArgumentChecker.ThrowArgumentException(AnalyzeMethodName,
                "attachmentFilter",

                "If attachmentFilter is HasAttachmentsFromParticipant1, a"
                + " first participant must also be specified.",

                null
                );
            }

            if (isReplyFromParticipant1.HasValue && !bHasFirstParticipant)
            {
            oArgumentChecker.ThrowArgumentException(AnalyzeMethodName,
                "optionaIsReplyFromParticipant1",

                "If isReplyFromParticipant1 is specified, a first participant"
                + " must also be specified."
                ,
                null
                );
            }
        }